| --- |
| pretty_name: Insurance Claims & Customer Data (Synthetic Sandbox) |
| license: other |
| license_name: mixed-see-card |
| language: |
| - en |
| tags: |
| - insurance |
| - rag |
| - data-engineering |
| - synthetic |
| - ocr |
| - mlops |
| task_categories: |
| - question-answering |
| - table-question-answering |
| - image-to-text |
| size_categories: |
| - 1K<n<10K |
| --- |
| |
| ## Quick start — get everything in one command |
|
|
| ```bash |
| pip install -U huggingface_hub |
| hf download EMTIAZZ/data-estate --repo-type dataset --local-dir ./data-estate |
| ``` |
|
|
| This downloads **everything** (all tables, PDFs, scanned images, emails, and transcripts) into |
| `./data-estate`. See [How to download](#how-to-download) for more ways. |
|
|
| --- |
|
|
| ## Hints |
|
|
| These are **hints, not answers**. They point out what to look for in each kind of data and what |
| to think about. Picking the tools and building the pipeline is your job. |
|
|
| All the data is connected: the same customer, policy, and claim show up in many places. Keep that |
| connection through every step, so any answer can be traced back to where it came from. |
|
|
| ### The kinds of data, and what to think about |
|
|
| | Kind of data | How to ingest it (batch / streaming) | Where to keep it | |
| |---|---|---| |
| | Customer records (tables) | Load all the old data once (**batch**), then capture new changes as they happen (**streaming**) | A database with tables you can join | |
| | Policy and claim records (tables) | Same — load everything once (**batch**), then keep capturing changes (**streaming**) | A database with tables you can join | |
| | PDFs and scanned forms (images — you must read the text out first) | Load the old pile once (**batch**); when a new file arrives, read it then (**streaming**) | Keep the original files; put the text you pull out in a database, and also in a **retrieval (search) index** | |
| | Emails (with reply history; personal info inside the text) | Load the old emails once (**batch**); **stream** new ones as they arrive | Keep the originals; put the text in a **retrieval (search) index** | |
| | Call transcripts (spoken chats; personal info inside the text) | Load the old ones once (**batch**); **stream** new ones as calls finish | Keep the originals; put the text in a **retrieval (search) index** | |
| | Reference support text | Just load it once (**batch**) | A database / search index | |
|
|
| ### Where to store things |
|
|
| - **Original files:** keep every file exactly as it came in, so you can always redo the work. |
| - **Cleaned data:** **normalized, deduplicated** tables — cleaned to one common format with |
| duplicates removed — so you can join them. |
| - **Search data:** text turned into **embeddings** (numbers that capture meaning) kept in a |
| **retrieval index**. Think about mixing keyword search with **semantic** (meaning-based) |
| search, and keeping each customer's data separate. |
| - **History:** a note of where each piece of data came from (file → cleaned → search → answer). |
|
|
| ### Q1 — ingesting the data (batch vs. streaming) |
|
|
| Decide which data you load **once** (the old history) and which data **keeps changing**. The |
| tables can be loaded once and then kept up to date. The files (documents, emails, calls) can be |
| loaded in bulk, then new ones handled as they arrive. The main question: where does **batch** |
| loading fit (big one-time loads), and where does **streaming** fit (handling items as they |
| arrive)? |
|
|
| ### Q2 — clean, deduplicate, and normalize (and handle personal info) |
|
|
| - Personal info is **not only in the obvious table columns** — it's also inside the email text, |
| the call transcripts, and printed on the documents. So you must find it in the free text too, |
| after you pull the text out. |
| - **Deduplicate:** some customer records are the **same person saved more than once**, under |
| different IDs, with small differences (capital letters, spaces, a changed phone format). Match |
| people by who they are, not by their ID. For documents, compare both the image and the text; |
| for emails, don't count the same quoted message twice. |
| - **Normalize:** the tables don't use the **same column names or date format** — clean them into |
| one common shape. |
|
|
| ### Q3 — getting data ready for search (chunks, embeddings, retrieval index) |
|
|
| - Split each kind of data into **chunks** in a sensible way: long documents, single table rows, |
| one email at a time, or one part of a conversation. |
| - Turn the chunks into **embeddings** and store them in a **retrieval index**. Only re-embed the |
| data that **changed**. Keep each customer's data separate. Think about how this stays fast with |
| millions of items, and how to mix keyword search with **semantic** (meaning-based) search. |
|
|
| ### Q4 — preparing data to train models |
|
|
| - Build training and test sets from the **cleaned** data. Remove personal info first. Make sure |
| the **same person is never in both the training set and the test set**. |
| - When an input has a known correct answer (for example, a document and the values it should |
| produce), build those input–answer pairs from the connected records. |
| - Plan how you **save versions** of your datasets, track your experiments, and undo a change if |
| needed. |
|
|
| ### Q5 — keeping it healthy over time |
|
|
| - Keep an eye on **health** (is the data fresh? did reading the files work? is anything piling |
| up?), **changes over time** (new kinds of records or new form layouts), and **answer quality** |
| (does each answer point to a real source?). |
| - Keep a record of **where each piece of data came from**, control **who can see what**, and plan |
| for **changes to the tables** so they don't quietly break your joins. |
|
|
| --- |
|
|
| ## What's inside |
|
|
| ``` |
| data-estate/ |
| ├── structured/ # the tables (load into a database) |
| │ ├── crm_customers.csv # customers + personal info |
| │ ├── erp_policies.csv # policies (different column names + date format) |
| │ ├── claims.csv # claims, linked to policies + customers |
| │ └── postgres_dump.sql # ready-to-load database file for all three tables |
| ├── documents/ # claim forms |
| │ ├── pdf/<claim_no>.pdf # 450 claim-form PDFs |
| │ └── scans/<claim_no>.png # the same 450 forms as messy "scanned" images |
| ├── emails/thread_*.txt # 700 support email threads (reply history + personal info) |
| ├── transcripts/call_*.txt # 350 call transcripts (filler words + spoken personal info) |
| ├── real/ # extra real support-chat data |
| │ ├── customer_support_faqs/data.csv |
| │ └── bitext_customer_support/data.csv |
| ├── *_index.json # simple lists of the emails / calls / documents |
| ├── MANIFEST.json # counts + how things connect + the messy parts |
| ├── examples/quickstart.py # a ready-to-run example (load, join, read a file) |
| └── generate.py # the script that made the synthetic data |
| ``` |
|
|
| ### The table files (in `structured/`) |
|
|
| | File | Comes from | Main columns | Notes | |
| |---|---|---|---| |
| | `crm_customers.csv` | CRM | `customer_id`, `full_name`, `email`, `phone`, `dob`, `ssn`, address… | lowercase names, ISO dates. **About 8% are duplicate rows.** | |
| | `erp_policies.csv` | ERP | `PolicyNo`, `CustomerID`, `LineOfBusiness`, `Premium`, `EffectiveDate`… | different name style, **`MM/DD/YYYY` dates** (different on purpose). | |
| | `claims.csv` | claims | `claim_no`, `policy_no`, `customer_id`, `line`, `filed_date`, `amount_claimed`, `status` | links policies and customers. | |
|
|
| ### The files (documents, emails, calls) |
|
|
| - **`documents/scans/<claim_no>.png`** — claim forms made to look like real scans (gray, tilted, |
| noisy, blurry). **Read the text and fields out of these images.** |
| - **`documents/pdf/<claim_no>.pdf`** — the clean PDF of each form. |
| - **`emails/thread_*.txt`** — back-and-forth support emails with reply history; the customer's |
| **personal info is in the signature**. |
| - **`transcripts/call_*.txt`** — agent/customer phone chats with filler words ("um", "uh") and |
| **personal info said out loud** (phone, date of birth). |
|
|
| ### How everything connects |
|
|
| ``` |
| crm_customers.customer_id ─┐ |
| ├─► erp_policies.CustomerID |
| │ └─ erp_policies.PolicyNo ─► claims.policy_no |
| └─► claims.customer_id |
| └─ claims.claim_no ─► documents/{pdf,scans}/<claim_no> |
| ─► emails (subject + body) |
| ─► transcripts (header + body) |
| ``` |
|
|
| The **same person shows up in a claim, a scanned form, an email, and a call.** That's what makes |
| joining, cleaning, and tracing the data a real challenge. |
|
|
| ### The messy parts (on purpose) |
|
|
| - **Duplicate customers:** the same person saved under different IDs, with capital-letter, |
| spacing, and typo changes, different phone formats, slightly different emails, and some missing |
| fields. |
| - **Different table styles:** one table uses lowercase names + ISO dates, the other uses |
| CamelCase names + `MM/DD/YYYY` dates. |
| - **Personal info inside text:** in emails, transcripts, and scanned forms. |
| - **Messy scans:** hard to read, like real scans. |
|
|
| ### How much data |
|
|
| | Data | Count | |
| |---|---| |
| | Customer rows (including duplicates) | 2,592 | |
| | Policies | 3,100 | |
| | Claims | 3,900 | |
| | Scanned forms (PNG) + PDFs | 450 + 450 | |
| | Support email threads | 700 | |
| | Call transcripts | 350 | |
| | Extra real support records | 1,700 | |
|
|
| --- |
|
|
| ## How to download |
|
|
| ### Option A — one command, everything (easiest) |
|
|
| ```bash |
| pip install -U huggingface_hub |
| hf download EMTIAZZ/data-estate --repo-type dataset --local-dir ./data-estate |
| ``` |
|
|
| ### Option B — Python, everything |
|
|
| ```python |
| from huggingface_hub import snapshot_download |
| path = snapshot_download(repo_id="EMTIAZZ/data-estate", |
| repo_type="dataset", local_dir="data-estate") |
| print("downloaded to:", path) |
| ``` |
|
|
| ### Option C — only part of it (just the images, or just the tables) |
|
|
| ```python |
| from huggingface_hub import snapshot_download |
| # only the scanned images: |
| snapshot_download("EMTIAZZ/data-estate", repo_type="dataset", |
| local_dir="scans_only", allow_patterns=["documents/scans/*"]) |
| # only the tables: |
| snapshot_download("EMTIAZZ/data-estate", repo_type="dataset", |
| local_dir="tables_only", allow_patterns=["structured/*"]) |
| ``` |
|
|
| ### Option D — one file, no extra tools |
|
|
| ```python |
| import pandas as pd |
| url = "https://huggingface.co/datasets/EMTIAZZ/data-estate/resolve/main/structured/claims.csv" |
| claims = pd.read_csv(url) # loads straight from the web |
| ``` |
| ```bash |
| # or with curl: |
| curl -L -o claims.csv "https://huggingface.co/datasets/EMTIAZZ/data-estate/resolve/main/structured/claims.csv" |
| ``` |
|
|
| ### Option E — git clone (needs git-lfs for the images/PDFs) |
|
|
| ```bash |
| git lfs install |
| git clone https://huggingface.co/datasets/EMTIAZZ/data-estate |
| ``` |
|
|
| --- |
|
|
| ## How to use it |
|
|
| ### Load and join the tables |
|
|
| ```python |
| import pandas as pd |
| root = "data-estate" # the folder you downloaded |
| cust = pd.read_csv(f"{root}/structured/crm_customers.csv") |
| pol = pd.read_csv(f"{root}/structured/erp_policies.csv") |
| claims = pd.read_csv(f"{root}/structured/claims.csv") |
| |
| # join the three tables (the column names don't match, so map them): |
| full = (claims |
| .merge(cust, on="customer_id", how="left") |
| .merge(pol, left_on="policy_no", right_on="PolicyNo", how="left")) |
| print(full.shape) |
| ``` |
|
|
| ### Load the tables into a database |
|
|
| ```bash |
| createdb insurance |
| psql -d insurance -f data-estate/structured/postgres_dump.sql |
| ``` |
|
|
| ### Open a scanned form and find its correct values |
|
|
| ```python |
| from PIL import Image |
| import pandas as pd, glob, os |
| |
| root = "data-estate" |
| scan = sorted(glob.glob(f"{root}/documents/scans/*.png"))[0] |
| claim_no = os.path.basename(scan).replace(".png", "") |
| img = Image.open(scan) # read the text out of this image |
| truth = pd.read_csv(f"{root}/structured/claims.csv").query("claim_no == @claim_no") |
| print(claim_no, img.size, "\ncorrect values:\n", truth.T) |
| ``` |
|
|
| ### Read an email or a transcript |
|
|
| ```python |
| print(open(f"{root}/emails/thread_0000.txt").read()) |
| print(open(f"{root}/transcripts/call_0000.txt").read()) |
| ``` |
|
|
| ### Or just run the example |
|
|
| ```bash |
| python data-estate/examples/quickstart.py data-estate |
| ``` |
|
|
