AI Image Reader: Extracting Financial Data Made Easy

import pytesseract
from PIL import Image
import cv2
import numpy as np

def preprocess_image(image_path):
    # Read the image
    img = cv2.imread(image_path)
    
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Apply thresholding to preprocess the image
    gray = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
    
    # Apply dilation to connect text components
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
    gray = cv2.dilate(gray, kernel, iterations=1)
    
    return gray

def extract_text_from_image(image_path):
    # Preprocess the image
    processed_image = preprocess_image(image_path)
    
    # Extract text using Tesseract
    text = pytesseract.image_to_string(processed_image)
    
    return text

def parse_financial_data(text):
    # Add custom parsing logic for financial data
    # This is a simple example - you'd want to add more sophisticated parsing
    import re
    
    # Find amounts
    amounts = re.findall(r'\$\d+(?:\.\d{2})?', text)
    
    # Find dates
    dates = re.findall(r'\d{2}/\d{2}/\d{4}', text)
    
    return {
        'amounts': amounts,
        'dates': dates
    }

# Example usage
if __name__ == "__main__":
    image_path = "financial_document.jpg"
    extracted_text = extract_text_from_image(image_path)
    financial_data = parse_financial_data(extracted_text)
    print("Extracted Amounts:", financial_data['amounts'])
    print("Extracted Dates:", financial_data['dates'])

import tensorflow as tf
from tensorflow.keras import layers, models

def create_document_classifier():
    model = models.Sequential([
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(300, 300, 3)),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.Flatten(),
        layers.Dense(64, activation='relu'),
        layers.Dense(4, activation='softmax')  # For 4 document types
    ])
    
    model.compile(optimizer='adam',
                 loss='sparse_categorical_crossentropy',
                 metrics=['accuracy'])
    
    return model

# Example document types: invoice, receipt, bank statement, financial report
document_types = ['invoice', 'receipt', 'bank_statement', 'financial_report']

from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

def analyze_financial_document(endpoint, key, document_path):
    document_analysis_client = DocumentAnalysisClient(
        endpoint=endpoint, 
        credential=AzureKeyCredential(key)
    )
    
    with open(document_path, "rb") as f:
        poller = document_analysis_client.begin_analyze_document(
            "prebuilt-document", document=f
        )
    result = poller.result()
    
    # Extract key-value pairs
    for kv_pair in result.key_value_pairs:
        key = kv_pair.key.content if kv_pair.key else ""
        value = kv_pair.value.content if kv_pair.value else ""
        print(f"Key: {key}, Value: {value}")
        
    # Extract tables
    for table in result.tables:
        print("Table found:")
        for cell in table.cells:
            print(f"Cell text: {cell.content}")

from transformers import LayoutLMv2Processor, LayoutLMv2ForTokenClassification
import torch

class InvoiceProcessor:
    def __init__(self):
        self.processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased")
        self.model = LayoutLMv2ForTokenClassification.from_pretrained("microsoft/layoutlmv2-base-uncased")
        
    def process_invoice(self, image_path):
        # Load and preprocess image
        image = Image.open(image_path).convert("RGB")
        encoded_inputs = self.processor(
            image,
            return_tensors="pt",
            padding="max_length",
            truncation=True
        )
        
        # Make prediction
        outputs = self.model(**encoded_inputs)
        predictions = outputs.logits.argmax(-1).squeeze().tolist()
        
        # Process predictions
        tokens = self.processor.tokenizer.convert_ids_to_tokens(encoded_inputs["input_ids"].squeeze().tolist())
        
        return self._extract_invoice_data(tokens, predictions)
    
    def _extract_invoice_data(self, tokens, predictions):
        # Add custom logic to extract specific fields like:
        # - Invoice number
        # - Date
        # - Amount
        # - Vendor details
        pass

# Example usage
invoice_processor = InvoiceProcessor()
result = invoice_processor.process_invoice("invoice.jpg")