Ejercicio: Análisis de Texto con Amazon Comprehend ​

Escenario ​

Implementaremos un sistema de análisis de feedback de clientes usando Amazon Comprehend para:

• Detectar el sentimiento general
• Identificar entidades clave
• Extraer frases clave
• Detectar idiomas

Parte 1: Configuración Inicial ​

1. Configurar Permisos IAM ​

1. Ve a IAM > Roles:

   Create role
   Use case: Comprehend
   Name: ComprehendAnalysisRole

2. Adjuntar políticas:

   AmazonComprehendFullAccess
   CloudWatchLogsFullAccess

2. Configurar el Entorno ​

# Instalar dependencias
pip install boto3 pandas numpy

# Configurar AWS CLI (si no está configurado)
aws configure

3. Estructura del Proyecto ​

sentiment-analysis/
├── src/
│   ├── analyzer.py
│   ├── utils.py
│   └── config.py
├── data/
│   ├── input/
│   └── output/
├── tests/
│   └── test_analyzer.py
└── README.md

Parte 2: Implementar el Analizador ​

1. Crear Configuración Base ​

# config.py
COMPREHEND_CONFIG = {
    'region_name': 'us-east-1',
    'language_code': 'es',
    'batch_size': 25
}

OUTPUT_PATHS = {
    'sentiment': 'data/output/sentiment/',
    'entities': 'data/output/entities/',
    'phrases': 'data/output/phrases/'
}

2. Implementar Analizador Principal ​

# analyzer.py
import boto3
import json
from datetime import datetime

class TextAnalyzer:
    def __init__(self, region_name='us-east-1'):
        self.comprehend = boto3.client('comprehend', region_name=region_name)
        
    def analyze_sentiment(self, text):
        response = self.comprehend.detect_sentiment(
            Text=text,
            LanguageCode='es'
        )
        return response
        
    def detect_entities(self, text):
        response = self.comprehend.detect_entities(
            Text=text,
            LanguageCode='es'
        )
        return response
        
    def detect_key_phrases(self, text):
        response = self.comprehend.detect_key_phrases(
            Text=text,
            LanguageCode='es'
        )
        return response

Parte 3: Implementar Procesamiento por Lotes ​

1. Crear Procesador de Lotes ​

# utils.py
def batch_processor(texts, batch_size=25):
    """Procesa textos en lotes"""
    for i in range(0, len(texts), batch_size):
        yield texts[i:i + batch_size]

def save_results(results, filename):
    """Guarda resultados en JSON"""
    with open(filename, 'w') as f:
        json.dump(results, f, indent=2)

2. Implementar Análisis en Lote ​

def batch_analyze_sentiment(self, texts):
    results = []
    for batch in batch_processor(texts):
        response = self.comprehend.batch_detect_sentiment(
            TextList=batch,
            LanguageCode='es'
        )
        results.extend(response['ResultList'])
    return results

Parte 4: Implementar Monitoreo ​

1. Configurar CloudWatch ​

def setup_monitoring():
    cloudwatch = boto3.client('cloudwatch')
    log_group = 'comprehend-analysis'
    
    return cloudwatch, log_group

2. Implementar Logging ​

def log_metrics(cloudwatch, metrics):
    cloudwatch.put_metric_data(
        Namespace='ComprehendAnalysis',
        MetricData=[
            {
                'MetricName': 'ProcessedTexts',
                'Value': metrics['processed_count'],
                'Unit': 'Count'
            }
        ]
    )

Parte 5: Prueba del Sistema ​

1. Datos de Prueba ​

test_data = [
    "El servicio al cliente de AWS es excelente.",
    "Tuve problemas con la facturación este mes.",
    "La documentación es muy completa y útil.",
    "El soporte técnico respondió rápidamente.",
    "Los precios podrían ser más competitivos."
]

2. Ejecutar Análisis ​

analyzer = TextAnalyzer()
results = analyzer.batch_analyze_sentiment(test_data)

Verificación ​

1. Verificar Análisis de Sentimiento ​

• [ ] Sentimientos detectados correctamente
• [ ] Puntuaciones de confianza razonables
• [ ] Resultados guardados correctamente

2. Verificar Detección de Entidades ​

• [ ] Entidades identificadas correctamente
• [ ] Tipos de entidades clasificados adecuadamente
• [ ] No hay falsos positivos evidentes

3. Verificar Rendimiento ​

• [ ] Tiempos de respuesta aceptables
• [ ] Procesamiento por lotes funcionando
• [ ] Métricas registradas en CloudWatch

Troubleshooting Común ​

Error de Permisos ​

1. Verificar rol IAM
2. Revisar política de permisos
3. Verificar configuración de AWS CLI

Error de Análisis ​

1. Verificar formato del texto
2. Revisar límites de caracteres
3. Confirmar código de idioma correcto

Error de Procesamiento ​

1. Verificar tamaño de lotes
2. Revisar formato de entrada
3. Verificar manejo de errores

Limpieza ​

1. Eliminar logs de CloudWatch
2. Eliminar métricas personalizadas
3. Eliminar rol IAM si no se necesita
4. Limpiar archivos de salida

Puntos Importantes ​

1. Amazon Comprehend es serverless - no requiere infraestructura
2. Los costos se basan en el volumen de texto procesado
3. Soporta análisis en tiempo real y por lotes
4. Importante considerar los límites de servicio

Para el examen Cloud Practitioner, enfócate en:

• Casos de uso de Amazon Comprehend
• Beneficios del procesamiento de lenguaje natural
• Integración con otros servicios AWS
• Aspectos básicos de seguridad y permisos

He estructurado el ejercicio de manera similar al ejemplo proporcionado, incluyendo:

1. Una clara división por partes/secciones
2. Pasos detallados con comandos y código específicos
3. Sección de verificación con checklists
4. Troubleshooting común
5. Proceso de limpieza
6. Puntos importantes para recordar

Para comenzar con el ejercicio, necesitarás:

1. Una cuenta AWS con acceso a Amazon Comprehend
2. AWS CLI configurado
3. Python y boto3 instalados
4. Permisos IAM adecuados