AWS Review
English

Appearance

On this page

Ejercicio: Análisis de Imágenes con Amazon Rekognition ​

Escenario ​

Implementaremos un sistema de análisis de imágenes usando Amazon Rekognition para:

  • Detectar objetos y escenas
  • Reconocer rostros y expresiones
  • Detectar texto en imágenes
  • Analizar contenido inapropiado
  • Comparar similitud entre rostros

Parte 1: Configuración Inicial ​

1. Configurar Permisos IAM ​

  1. Ve a IAM > Roles:

    Create role
Use case: Rekognition
Name: RekognitionAnalysisRole

  2. Adjuntar políticas:

    AmazonRekognitionFullAccess
AmazonS3ReadOnlyAccess
CloudWatchLogsFullAccess

2. Configurar Bucket S3 ​

bash
# Crear bucket para imágenes
aws s3 mb s3://my-rekognition-images-[tu-sufijo-único]

# Crear estructura de carpetas
aws s3api put-object --bucket my-rekognition-images-[tu-sufijo-único] --key input/
aws s3api put-object --bucket my-rekognition-images-[tu-sufijo-único] --key output/

3. Estructura del Proyecto ​

image-analysis/
├── src/
│   ├── image_analyzer.py
│   ├── utils.py
│   └── config.py
├── images/
│   ├── input/
│   └── output/
├── tests/
│   └── test_analyzer.py
└── README.md

Parte 2: Implementar el Analizador ​

1. Crear Configuración Base ​

python
# config.py
REKOGNITION_CONFIG = {
    'region_name': 'us-east-1',
    'confidence_threshold': 80.0,
    'max_labels': 10,
    'max_faces': 5
}

S3_CONFIG = {
    'bucket_name': 'my-rekognition-images-[tu-sufijo-único]',
    'input_prefix': 'input/',
    'output_prefix': 'output/'
}

2. Implementar Analizador Principal ​

python
# image_analyzer.py
import boto3
import json
from datetime import datetime

class ImageAnalyzer:
    def __init__(self, region_name='us-east-1'):
        self.rekognition = boto3.client('rekognition', region_name=region_name)
        self.s3 = boto3.client('s3')
        
    def detect_labels(self, bucket, image_key):
        """Detecta objetos y escenas en la imagen"""
        response = self.rekognition.detect_labels(
            Image={
                'S3Object': {
                    'Bucket': bucket,
                    'Name': image_key
                }
            },
            MaxLabels=10,
            MinConfidence=80
        )
        return response['Labels']
        
    def detect_faces(self, bucket, image_key):
        """Analiza rostros en la imagen"""
        response = self.rekognition.detect_faces(
            Image={
                'S3Object': {
                    'Bucket': bucket,
                    'Name': image_key
                }
            },
            Attributes=['ALL']
        )
        return response['FaceDetails']
        
    def detect_text(self, bucket, image_key):
        """Detecta texto en la imagen"""
        response = self.rekognition.detect_text(
            Image={
                'S3Object': {
                    'Bucket': bucket,
                    'Name': image_key
                }
            }
        )
        return response['TextDetections']
        
    def compare_faces(self, source_bucket, source_key, target_bucket, target_key):
        """Compara rostros entre dos imágenes"""
        response = self.rekognition.compare_faces(
            SourceImage={
                'S3Object': {
                    'Bucket': source_bucket,
                    'Name': source_key
                }
            },
            TargetImage={
                'S3Object': {
                    'Bucket': target_bucket,
                    'Name': target_key
                }
            },
            SimilarityThreshold=90
        )
        return response['FaceMatches']
        
    def detect_moderation_labels(self, bucket, image_key):
        """Detecta contenido inapropiado"""
        response = self.rekognition.detect_moderation_labels(
            Image={
                'S3Object': {
                    'Bucket': bucket,
                    'Name': image_key
                }
            },
            MinConfidence=75
        )
        return response['ModerationLabels']

Parte 3: Implementar Utilidades ​

1. Crear Funciones de Ayuda ​

python
# utils.py
import os
import json

def upload_image(s3_client, image_path, bucket, key):
    """Sube una imagen a S3"""
    with open(image_path, 'rb') as image:
        s3_client.upload_fileobj(image, bucket, key)
        
def save_analysis(results, output_path):
    """Guarda resultados del análisis"""
    with open(output_path, 'w') as f:
        json.dump(results, f, indent=2)
        
def get_image_metadata(s3_client, bucket, key):
    """Obtiene metadata de la imagen"""
    response = s3_client.head_object(Bucket=bucket, Key=key)
    return response['Metadata']

2. Implementar Procesamiento por Lotes ​

python
def process_directory(directory_path, analyzer, bucket):
    """Procesa todas las imágenes en un directorio"""
    results = {}
    for filename in os.listdir(directory_path):
        if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
            image_path = os.path.join(directory_path, filename)
            key = f"input/{filename}"
            
            # Subir imagen
            upload_image(analyzer.s3, image_path, bucket, key)
            
            # Analizar imagen
            results[filename] = {
                'labels': analyzer.detect_labels(bucket, key),
                'faces': analyzer.detect_faces(bucket, key),
                'text': analyzer.detect_text(bucket, key)
            }
    
    return results

Parte 4: Script Principal de Ejecución ​

1. Crear Script Principal ​

python
# main.py
from image_analyzer import ImageAnalyzer
from utils import process_directory
import config

def main():
    # Inicializar analizador
    analyzer = ImageAnalyzer(region_name=config.REKOGNITION_CONFIG['region_name'])
    
    # Procesar imágenes
    results = process_directory(
        'images/input',
        analyzer,
        config.S3_CONFIG['bucket_name']
    )
    
    # Guardar resultados
    save_analysis(results, 'images/output/analysis_results.json')
    
if __name__ == '__main__':
    main()

Parte 5: Prueba del Sistema ​

1. Preparar Imágenes de Prueba ​

bash
# Crear directorio de pruebas
mkdir -p images/input
mkdir -p images/output

# Copiar algunas imágenes de prueba
cp path/to/test/images/* images/input/

2. Ejecutar Análisis ​

python
python main.py

Verificación ​

1. Verificar Detección de Objetos ​

  • [ ] Objetos identificados correctamente
  • [ ] Confianza por encima del umbral
  • [ ] Etiquetas relevantes detectadas

2. Verificar Análisis de Rostros ​

  • [ ] Rostros detectados correctamente
  • [ ] Atributos faciales identificados
  • [ ] Expresiones reconocidas

3. Verificar Detección de Texto ​

  • [ ] Texto extraído correctamente
  • [ ] Orientación del texto correcta
  • [ ] Confianza de detección adecuada

Troubleshooting Común ​

Error de Permisos ​

  1. Verificar rol IAM
  2. Revisar permisos de S3
  3. Confirmar acceso a Rekognition

Error de Procesamiento ​

  1. Verificar formato de imagen
  2. Revisar tamaño de archivo
  3. Confirmar resolución de imagen

Error de Almacenamiento ​

  1. Verificar permisos de bucket
  2. Revisar nombres de archivos
  3. Confirmar rutas de acceso

Limpieza ​

  1. Eliminar imágenes de S3
  2. Eliminar archivos locales
  3. Eliminar rol IAM si no se necesita
  4. Limpiar archivos de resultados

Puntos Importantes ​

  1. Amazon Rekognition es un servicio serverless
  2. Los costos se basan en el número de imágenes procesadas
  3. Soporta tanto imágenes como video
  4. Importante considerar las mejores prácticas de seguridad

Para el examen Cloud Practitioner, enfócate en:

  • Casos de uso de Amazon Rekognition
  • Beneficios del procesamiento de imágenes en la nube
  • Integración con otros servicios AWS
  • Consideraciones de seguridad y cumplimiento

Este ejercicio proporciona una estructura completa para trabajar con Amazon Rekognition, incluyendo:

  1. Detección de objetos y escenas
  2. Análisis facial
  3. Detección de texto
  4. Comparación de rostros
  5. Detección de contenido inapropiado

Para comenzar necesitarás:

  1. Una cuenta AWS con acceso a Rekognition
  2. AWS CLI configurado
  3. Python con boto3 instalado
  4. Algunas imágenes de prueba
  5. Permisos IAM apropiados

El código está organizado de manera modular y puede expandirse fácilmente para incluir más funcionalidades como:

  • Análisis de video
  • Procesamiento en tiempo real
  • Integración con bases de datos
  • Generación de reportes detallados