Creación de una herramienta de análisis de datos con Python, el conjunto de datos SROIE y aprendizaje automático

Florian Zyprian

Si eres desarrollador de Python y quieres crear una herramienta de análisis sintáctico de datos, este tutorial es para ti. Le mostraremos cómo crear una herramienta eficaz de análisis sintáctico de documentos con Python y el conjunto de datos SROIE y le presentaremos las posibilidades del SDK Konfuzio. ¡Empecemos!

Aquí encontrará una breve introducción al análisis sintáctico de cadenas en Python.

Paso 1: Configure su entorno

Antes de empezar, asegúrate de que Python y todas las librerías necesarias están instaladas. Para ello, ejecute los siguientes comandos en su línea de comandos o terminal:

# Instalar paquetes Python
pip install opencv-python tensorflow numpy scikit-learn

Paso 2: Cargar el conjunto de datos SROIE

El conjunto de datos SROIE consta de imágenes de Recibos y los archivos de anotación asociados. Así es como puede cargarlos:

importar os
importar cv2
# Directorios para imágenes y anotaciones SROIE
image_folder = "ruta/a/SROIE/imagen/carpeta"
annotation_folder = "ruta/a/SROIE/anotaciones/carpeta"
def load_sroie_dataset(image_folder, annotation_folder):
    """Carga las imágenes y el texto correspondiente del conjunto de datos SROIE""".
    imágenes, textos_extraídos = [], []
    for nombre_archivo in os.listdir(carpeta_anotaciones):
        with open(os.path.join(carpeta_anotaciones, nombre_archivo), "r") as archivo:
            texto_extraído = file.readlines()[1].strip()
            ruta_imagen = os.path.join(carpeta_imagen, nombre_archivo.replace(".txt", ".jpg"))
            imagen = cv2.imread(ruta_imagen)
            images.append(imagen)
            extracted_texts.append(texto_extraído)
    devolver imágenes, textos_extraídos
images, extracted_texts = load_sroie_dataset(image_folder, annotation_folder)

Paso 3: Preparar el conjunto de datos

Ahora queremos preprocesar las imágenes del conjunto de datos SROIE para su posterior entrenamiento:

carpeta_salida = "ruta/carpeta/salida"
def preprocess_images(carpeta_imagen, carpeta_anotacion, carpeta_salida):
    """Preprocesa las imágenes y guárdalas en el directorio de salida."""
    for nombre_archivo in os.listdir(carpeta_anotacion):
        with open(os.path.join(carpeta_anotaciones, nombre_archivo), "r") as archivo:
            texto_extraído = file.readlines()[1].strip()
            ruta_imagen = os.path.join(carpeta_imagen, nombre_archivo.replace(".txt", ".jpg"))
            imagen = cv2.imread(ruta_imagen)
            # Puede añadir pasos de preprocesamiento de imágenes aquí
            ruta_salida = os.path.join(carpeta_salida, nombre_archivo.replace(".txt", ".jpg"))
            cv2.imwrite(ruta_salida, imagen)
preprocess_images(image_folder, annotation_folder, output_folder)

Otro interesante conjunto de datos lo ofrece FUNSD+. Lea más ahora.

Paso 4: Ajuste y evaluación con el modelo donut

Para una mayor precisión Análisis sintáctico de documentos tendremos un modelo de donut preentrenado afinar en nuestros datos preprocesados:

importar tensorflow como tf
from tensorflow.keras import capas, modelos
from sklearn.model_selection import dividir_entrenamiento_prueba
# Divide los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(images, extracted_texts, test_size=0.2, random_state=42)
def create_donut_model(input_shape, num_classes):
    """Crea el modelo Donut CNN para el reconocimiento de textos"""".
    model = models.Sequential([
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=forma_entrada),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        capas.MaxPooling2D((2, 2)),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dense(num_classes, activación='softmax')
    ])
    devolver modelo
model = crear_donut_model((altura, anchura, canales), num_clases)
model.compile(optimiser='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.1)
pérdida_prueba, precisión_prueba = model.evaluate(X_prueba, y_prueba)

Resumen

La creación de una herramienta de análisis sintáctico de datos con Python y el conjunto de datos SROIE puede ser perfecta con el enfoque adecuado. Para obtener características y funcionalidades más avanzadas, integre el SDK de Konfuzio en sus proyectos. Eche un vistazo a la documentación de Konfuzio para obtener información completa.

¡Diviértase programando!

Más enlaces

    ¿Busca su empresa nuevos talentos en IA?

    Talento de primera clase en IA para su empresa

    Mediación especializada, máximo éxito sin esfuerzo: Nuestro socio Opushero le ayuda a encontrar los mejores talentos. Una red de agencias de consultoría especializadas que apoyan tanto a jóvenes aspirantes como a desarrolladores de IA experimentados. Recibe sugerencias de candidatos precalificados que quieren empezar a trabajar contigo.

    Sobre mí

    Más artículos interesantes

    Google Cloud con Vertex AI Konfuzio

    Guía Vertex AI: Implantación de Llama 2 en Google Cloud

    Vertex AI es el término colectivo para todo lo relacionado con soluciones o aplicaciones de IA en Google Cloud.

    Leer el artículo
    División de documentos

    Clasificación de documentos y separación de documentos mediante IA

    Uno de los problemas de la automatización de documentos que a menudo se pasa por alto y es realmente difícil, y que además resulta muy molesto en el día a día, es...

    Leer el artículo
    ingresos pasivos

    Ingresos pasivos como ingeniero de datos y científico de datos

    El mundo de la inteligencia artificial (IA) y el aprendizaje automático está creciendo rápidamente, y la necesidad de ingenieros de datos cualificados y...

    Leer el artículo
    Flecha arriba