Speichern von Amazon-Rekognition-Daten mit Amazon RDS und DynamoDB

Bei der Verwendung von Amazon Rekognition ist es wichtig APIs, sich daran zu erinnern, dass die API-Operationen keine der generierten Labels speichern. Sie können diese Labels speichern, indem Sie sie zusammen mit den Kennungen für die jeweiligen Bilder in der Datenbank platzieren.

Dieses Tutorial zeigt das Erkennen von Labels und das Speichern dieser erkannten Labels in einer Datenbank. Die in diesem Tutorial entwickelte Beispielanwendung liest Bilder aus einem Amazon S3 S3-Bucket, ruft den DetectLabelsVorgang für diese Bilder auf und speichert die resultierenden Labels in einer Datenbank. Die Anwendung speichert Daten entweder in einer Amazon-RDS-Datenbank-Instance oder einer DynamoDB-Datenbank, je nachdem, welchen Datenbanktyp Sie verwenden möchten.

Für dieses Tutorial verwenden Sie das AWS -SDK für Python. Weitere Python-Tutorials finden Sie auch im AWS Documentation SDK Examples GitHub Repo.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, müssen Sie Python installieren und die zur Einrichtung des AWS Python-SDK erforderlichen Schritte ausführen. Stellen Sie darüber hinaus sicher, dass Sie über Folgendes verfügen:

Sie haben ein AWS-Konto und eine IAM-Rolle erstellt

Sie haben das Python-SDK (Boto3) installiert

Haben Sie Ihre AWS Zugangsdaten richtig konfiguriert

Sie haben den Amazon-S3-Bucket erstellt und ihn mit Bildern gefüllt

Es wurde eine RDS-Datenbank-Instance erstellt, wenn RDS zum Speichern von Daten verwendet wurde

Labels für Bilder in einem Amazon-S3-Bucket abrufen

Schreiben Sie zunächst eine Funktion, die den Namen eines Bilds in Ihrem Amazon-S3-Bucket übernimmt und dieses Bild abruft. Dieses Bild wird angezeigt, um zu bestätigen, dass die richtigen Bilder an einen Aufruf übergeben werden DetectLabels, der auch in der Funktion enthalten ist.

1. Suchen Sie den Amazon-S3-Bucket, den Sie verwenden möchten, und notieren Sie sich seinen Namen. Sie rufen diesen Amazon-S3-Bucket auf und lesen die darin enthaltenen Bilder. Stellen Sie sicher, dass Ihr Bucket einige Bilder enthält, die an den DetectLabelsVorgang übergeben werden sollen.

2. Schreiben Sie den Code für die Verbindung mit Ihrem Amazon-S3-Bucket. Sie können mit Boto3 eine Verbindung zur Amazon-S3-Ressource herstellen, um ein Bild aus einem Amazon-S3-Bucket abzurufen. Sobald eine Verbindung mit der Amazon-S3-Ressource hergestellt ist, können Sie auf Ihren Bucket zugreifen, indem Sie der Bucket-Methode den Namen Ihres Amazon-S3-Buckets angeben. Nachdem Sie eine Verbindung zum Amazon-S3-Bucket hergestellt haben, rufen Sie mithilfe der Objekt-Methode Bilder aus dem Bucket ab. Mithilfe von Matplotlib können Sie diese Verbindung verwenden, um Ihre Bilder während der Verarbeitung zu visualisieren. Boto3 wird auch verwendet, um eine Verbindung zum Rekognition-Client herzustellen.

   Geben Sie im folgenden Code Ihre Region für den Parameter region_name an. Sie übergeben den Amazon S3 S3-Bucket-Namen und den Image-Namen an DetectLabels, der die Labels für das entsprechende Bild zurückgibt. Nachdem Sie nur die Labels aus der Antwort ausgewählt haben, werden sowohl der Name des Bildes als auch die Labels zurückgegeben.

   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. Speichern Sie diesen Code in einer Datei namens get_images.py.

Erstellen einer Amazon DynamoDB-Tabelle

Der folgende Code verwendet Boto3, um eine Verbindung zu DynamoDB herzustellen, und verwendet die CreateTable-DynamoDB-Methode, um eine Tabelle mit dem Namen „Bilder“ zu erstellen. Die Tabelle hat einen zusammengesetzten Primärschlüssel, der aus einem Partitionsschlüssel namens Image und einem Sortierschlüssel namens Labels besteht. Der Bildschlüssel enthält den Namen des Bilds, während der Labelschlüssel die diesem Bild zugewiesenen Labels speichert.

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)

Speichern Sie diesen Code in einem Editor und führen Sie ihn einmal aus, um eine DynamoDB-Tabelle zu erstellen.

Hochladen von Daten in DynamoDB

Nachdem die DynamoDB-Datenbank erstellt wurde und Sie über eine Funktion zum Abrufen von Labels für Bilder verfügen, können Sie die Labels in DynamoDB speichern. Der folgende Code ruft alle Bilder in einem S3-Bucket ab, ruft Labels für sie ab und speichert die Daten in DynamoDB.

1. Sie müssen den Code für das Hochladen der Daten auf DynamoDB schreiben. Eine Funktion namens get_image_names wird verwendet, um eine Verbindung zu Ihrem Amazon-S3-Bucket herzustellen. Sie gibt die Namen aller Bilder im Bucket als Liste zurück. Sie übergeben diese Liste an die read_image_from_S3-Funktion, die aus der von Ihnen erstellten get_images.py-Datei importiert wird.

   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. Die read_image_from_S3-Funktion, die wir zuvor erstellt haben, gibt den Namen des zu verarbeitenden Bilds und das Wörterbuch der mit diesem Bild verknüpften Labels zurück. Eine Funktion namens find_values wird verwendet, um nur die Labels aus der Antwort abzurufen. Der Name des Bilds und seine Labels können dann in Ihre DynamoDB-Tabelle hochgeladen werden.

   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. Sie verwenden eine dritte Funktion namens load_data, um die Bilder und Labels tatsächlich in die von Ihnen erstellte DynamoDB-Tabelle zu laden.

   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. Hier werden die drei Funktionen aufgerufen, die wir zuvor definiert haben, und die Operationen werden ausgeführt. Fügen Sie die drei oben definierten Funktionen zusammen mit dem folgenden Code zu einer Python-Datei hinzu. Führen Sie den Code aus.

   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!")

Sie haben gerade DetectLabelsLabels für Ihre Bilder generiert und diese Labels in einer DynamoDB-Instanz gespeichert. Stellen Sie sicher, dass Sie alle Ressourcen, die Sie während der Bearbeitung dieses Tutorials erstellt haben, beenden. Dadurch wird verhindert, dass Ihnen Ressourcen in Rechnung gestellt werden, die Sie nicht nutzen.

Eine MySQL-Datenbank in Amazon RDS erstellen

Bevor Sie fortfahren, stellen Sie sicher, dass Sie den Einrichtungsvorgang für Amazon RDS abgeschlossen und eine MySQL-DB-Instance mit Amazon RDS erstellt haben.

Der folgende Code verwendet die PyMySQL-Bibliothek und Ihre Amazon RDS-DB-Instance. Er erstellt eine Tabelle, die die Namen Ihrer Bilder und die mit diesen Bildern verknüpften Labels enthält. Amazon RDS empfängt Befehle zum Erstellen von Tabellen und zum Einfügen von Daten in Tabellen. Um Amazon RDS verwenden zu können, müssen Sie sich mit Ihrem Hostnamen, Benutzernamen und Passwort mit dem Amazon-RDS-Host verbinden. Sie stellen eine Verbindung zu Amazon RDS her, indem Sie diese Argumente für die PyMy connect SQL-Funktion bereitstellen und eine Instanz eines Cursors erstellen.

1. Ersetzen Sie im folgenden Code den Wert von Host durch Ihren Amazon-RDS-Host-Endpunkt und den Wert von Benutzer durch den Master-Benutzernamen, der Ihrer Amazon-RDS-Instance zugeordnet ist. Außerdem müssen Sie das Passwort durch das Master-Passwort für Ihren Hauptbenutzer ersetzen.

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

2. Erstellen Sie eine Datenbank und eine Tabelle, in die Sie Ihre Bild- und Labeldaten einfügen können. Führen Sie dazu eine Erstellungsabfrage aus und bestätigen Sie sie. Mit dem folgenden Code wird eine Datenbank erstellt. Führen Sie diesen Code nur einmal aus.

   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. Sobald die Datenbank erstellt wurde, müssen Sie eine Tabelle erstellen, in die Sie Ihre Bildnamen und Labels einfügen können. Um eine Tabelle zu erstellen, übergeben Sie zunächst den Befehl „use SQL“ zusammen mit dem Namen Ihrer Datenbank an die execute-Funktion. Nachdem die Verbindung hergestellt wurde, wird eine Abfrage zum Erstellen einer Tabelle ausgeführt. Der folgende Code stellt eine Verbindung mit der Datenbank her und erstellt dann eine Tabelle mit einem Primärschlüssel namens image_id, der aufgerufen wird, und einem Textattribut, in dem die Labels gespeichert sind. Verwenden Sie die Importe und Variablen, die Sie zuvor definiert haben, und führen Sie diesen Code aus, um eine Tabelle in Ihrer Datenbank zu erstellen.

   # 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!")

Daten in eine Amazon-RDS-MySQL-Tabelle hochladen

Nachdem Sie die Amazon-RDS-Datenbank und eine Tabelle in der Datenbank erstellt haben, können Sie Labels für Ihre Bilder abrufen und diese Labels in der Amazon-RDS-Datenbank speichern.

1. Stellen Sie eine Verbindung zu Ihrem Amazon-S3-Bucket her und rufen Sie die Namen aller Bilder im Bucket ab. Diese Bildnamen werden an die read_image_from_s3-Funktion übergeben, die Sie zuvor erstellt haben, um die Labels für alle Ihre Bilder abzurufen. Der folgende Code stellt eine Verbindung zu Ihrem Amazon-S3-Bucket her und gibt eine Liste aller Bilder in Ihrem Bucket zurück.

   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. Die Antwort von der DetectLabelsAPI enthält mehr als nur die Labels. Schreiben Sie also eine Funktion, um nur die Labelwerte zu extrahieren. Die folgende Funktion gibt eine Liste zurück, die nur die Labels enthält.

   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. Sie benötigen eine Funktion, um die Bildnamen und Labels in Ihre Tabelle einzufügen. Die folgende Funktion führt eine Einfügeabfrage aus und fügt ein beliebiges Paar von Bildnamen und Labels ein.

   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. Schließlich müssen Sie die Funktionen ausführen, die Sie oben definiert haben. Im folgenden Code werden die Namen aller Bilder in Ihrem Bucket gesammelt und der aufrufenden Funktion zur Verfügung gestellt DetectLabels. Anschließend werden die Labels und der Name des Bilds, auf das sie zutreffen, in Ihre Amazon-RDS-Datenbank hochgeladen. Kopieren Sie die drei oben definierten Funktionen zusammen mit dem folgenden Code in eine Python-Datei. Führen Sie die Python-Datei aus.

   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!")

Sie haben erfolgreich Labels für Ihre Bilder generiert und diese Labels mithilfe von Amazon RDS in einer MySQL-Datenbank gespeichert. DetectLabels Stellen Sie sicher, dass Sie alle Ressourcen, die Sie während der Bearbeitung dieses Tutorials erstellt haben, beenden. Dadurch wird verhindert, dass Ihnen Ressourcen in Rechnung gestellt werden, die Sie nicht nutzen.

Weitere AWS Multiservice-Beispiele finden Sie im AWS Documentation SDK Examples GitHub Repository.