SM projects https://indext.io ru Wed, 08 Apr 2026 14:57:40 +0300 Kaggle Dataset: promoPulse (promotional offers, coupons and deals) https://indext.io/tpost/1bdylo8r81-kaggle-dataset-promopulse-promotional-of https://indext.io/tpost/1bdylo8r81-kaggle-dataset-promopulse-promotional-of?amp=true Tue, 17 Mar 2026 17:56:00 +0300 Indext Data Lab Daily-updated collection of promotional offers, coupons, and deals from major US e-commerce websites.

Kaggle Dataset: promoPulse (promotional offers, coupons and deals)

Automated E-Commerce Promo Monitoring with LLM Extraction — promoPulse (Open Source Dataset)

Tag: E-Commerce · Data Pipeline · LLM Extraction · Open Source · Kaggle

The problem: promotional data is fragmented, stale, and unstructured

E-commerce teams and data scientists share the same frustration with promotional intelligence: there is no reliable, structured source of what competitors are running today. Deals pages are dynamic, return raw HTML, and change format without notice.

Manual monitoring doesn't scale. Five retailers, daily deal cycles, seasonal campaigns, flash sales — that's hundreds of promotions per day, each with a different discount structure, expiration logic, and format. Some have coupon codes, some percentage discounts, some are BOGO, some are free shipping with a minimum order. Normalizing all of that by hand is not a pipeline; it's a full-time job.

For data scientists and ML engineers, the problem is different but adjacent: training data for e-commerce entity extraction, promotion classification, and discount modeling is either paywalled, poorly structured, or not updated frequently enough to reflect real market behavior. What's missing is a transparent, daily-updated dataset with documented methodology, verified source URLs, and consistent schema — available in CSV, JSON, and Parquet.

The solution: multi-source scraping + LLM-powered structured extraction

promoPulse is a daily-updated dataset of promotional offers, coupons, and deals from major US e-commerce retailers. It is also a live demonstration of the Indext Data Lab extraction pipeline — fully documented, with every record traceable to its original source URL.

The pipeline runs in four stages:

Multi-source fetching. Content is retrieved from public deal pages using three scraping APIs in parallel — Jina, Tavily, and Firecrawl. Multiple sources per site improve coverage and provide redundancy when one API returns incomplete content.

LLM-powered extraction. Raw page text is processed by GPT-4o-mini and Llama-3.3-70B to identify structured fields: title, promo code, discount value, discount type, expiration date, and description. LLMs handle the format variation that makes rule-based extraction brittle.

Deduplication. Two-key logic runs at both daily and cumulative history levels. Primary key when a promo code exists: (source_site, promo_code). Fallback: (source_site, title, source_url, valid_until). Same-day re-runs merge without duplicating records.

Validation and normalization. Discount values are normalized to a consistent numeric format. Promo codes are verified against raw page content. JSON output is validated with a retry mechanism on extraction failures.

Stack: Jina · Tavily · Firecrawl · GPT-4o-mini · Llama-3.3-70B · Python · Parquet / CSV / JSON

Pipeline runs automatically every day at 08:00 UTC. Reliability over the last 35 days: 100%.

Results: 4,600+ records, 32 days of history, 5 retailers

Today's snapshot (2026-04-08):

Promotions found   212
Sites scraped        5
Coupon codes         6
Pipeline status     OK

Per-site breakdown:

Site	Promos	Max Discount	Codes
officedepot.com	107	54.5%	1
ulta.com	52	100.0%	1
shutterfly.com	18	50.0%	4
1800flowers.com	12	50.0%	0
homedepot.com	7	30.0%	0

Data quality across key fields:

Field	Fill Rate	Note
title	100%	Always present
discount_type	100%	Always classified
description	100%	Always present
discount_value	52%	Not all promos have numeric value
valid_until	34%	Retailers often omit expiry dates
promo_code	3%	Most discounts are automatic

The low fill rates on promo_code and valid_until reflect real-world retailer behavior, not extraction failures. Most promotions are automatic checkout discounts with no published expiration.

What you can build with this data

For e-commerce and marketing teams: benchmark your promotional frequency and discount depth against market leaders. Track which discount types competitors favor — percentage off, BOGO, free shipping, fixed amount. Identify seasonal cycles before they happen. The daily_stats.csv and site_stats.csv analytics files are ready for dashboarding without any preprocessing.

For data scientists and ML engineers: the dataset provides high-quality labeled training data for promotion entity extraction, discount classification, and e-commerce NLP models. The LLM-structured output with verified source URLs gives you full provenance on every record. The starter EDA notebook on Kaggle covers daily volume trends, discount type distribution, coupon frequency analysis, and day-of-week seasonality — ready to fork and run.

Dataset structure

dataset/
current/     # Latest extraction snapshot (CSV, JSON, Parquet)
history/     # Daily archives + full cumulative history
analytics/   # daily_stats.csv, site_stats.csv

Each record includes: title · promo_code · discount_value · discount_type · source_site · source_url · valid_from · valid_until · description · collect_date

License: CC BY 4.0 — use freely for research, commercial analytics, or model training with attribution.

Download the dataset →

Kaggle: https://www.kaggle.com/datasets/indext-data-lab-ai/promos-dataset

Fork the starter EDA notebook to run your own analysis immediately.

Need a custom data pipeline?

promoPulse covers US retailers updated daily. If your business needs monitoring of specific competitors, higher update frequency, additional geographies, or a fully integrated AI-driven extraction pipeline — Indext Data Lab builds these as custom data products.

Connect on LinkedIn → https://www.linkedin.com/company/indext-data-lab/

]]> Windows UI Element Detector https://indext.io/tpost/bzltacekm1-windows-ui-element-detector https://indext.io/tpost/bzltacekm1-windows-ui-element-detector?amp=true Tue, 17 Mar 2026 19:54:00 +0300 Indext Data Lab Upload a Windows screenshot to detect interactive UI elements (buttons, textboxes, checkboxes, dropdowns, icons, tabs, menu items).

Windows UI Element Detector

Windows UI Element Detector — Try the Live Demo

Tag: Computer Vision · Windows Automation · Live Demo · Open Source

What this tool does

Windows UI Element Detector is a browser-based demo of a computer-vision model that finds interactive elements in any Windows screenshot — buttons, text fields, checkboxes, dropdowns, icons, tabs, and menu items. Upload a screenshot, get bounding boxes and JSON output back in seconds.

Under the hood it runs YOLO11s fine-tuned on 3,000 synthetic Windows-style UI screenshots, with EasyOCR for text reading and rapidfuzz for fuzzy label matching. No cloud APIs. No data sent anywhere. Everything runs locally on the Space hardware.

Who needs this

UI automation agents that rely on native accessibility APIs — pywinauto, UIAutomation — regularly fail on custom-rendered controls, Electron apps, and heavily themed enterprise software. When the accessibility tree returns nothing, you need a vision fallback. This demo lets you test whether the model works on your specific application before integrating the library into your pipeline.

How to use the demo

Upload any Windows screenshot — a dialog box, a settings panel, a full desktop window. Adjust the confidence threshold to control how many detections appear. Use the IoU slider to tune overlap suppression. Filter by class if you only care about buttons or text fields. Hit Detect.

The overlay shows bounding boxes with class labels and confidence scores. The JSON output gives you the raw data: class name, bounding box coordinates, score — ready to copy into your integration.

Controls:

Confidence threshold — lower it to catch more elements, raise it to keep only high-certainty detections
IoU threshold (NMS) — controls how aggressively overlapping boxes are merged
Filter classes — select specific element types or leave empty to detect all seven

Model performance

Trained on NVIDIA RTX 5060 (Blackwell, 8 GB) for 120 epochs on 3,000 synthetic Windows screenshots generated via Playwright — no manual annotation required.

Overall metrics:

Metric	Value
mAP@50	0.989
mAP@50–95	0.954
Precision	0.996
Recall	0.973
CPU inference (Apple M2 Pro)	44–79 ms
GPU inference (RTX 5060)	2–5 ms

Per-class AP@50:

Component	Score
Button	0.9919
Textbox	0.9771
Checkbox	0.9864
Dropdown	0.9829
Icon	0.9950
Tab	0.9950
Menu item	0.9915

Use it in your project

The library installs with a single command. Model weights download automatically from HuggingFace on first run.

pip install -e .

from local_ui_locator import detect_elements, find_by_text, safe_click_point

# Detect all UI elements
detections = detect_elements("screenshot.png", conf=0.3)
for det in detections:
    print(f"{det.type}: {det.bbox} (score={det.score:.2f})")

# Find element by visible label
match = find_by_text("screenshot.png", query="Sign in")
if match:
    x, y = safe_click_point(match.bbox)
    print(f"Click at ({x}, {y})")

Full source code, training pipeline, and synthetic dataset generator on GitHub → https://github.com/Indext-Data-Lab/windows-ui-synth

Known limitations

The model performs best on standard Windows 10 and 11 UI. Heavily custom-styled applications — games, custom-skinned enterprise tools, non-standard widget libraries — may show lower accuracy due to the synthetic training data. The detector returns bounding boxes and class labels only; text content within elements requires the OCR layer. Seven element classes are supported in this release.

Stack

YOLO11s (Ultralytics) · EasyOCR · rapidfuzz · Playwright · MIT License

HuggingFace → https://huggingface.co/spaces/IndextDataLab/windows-ui-locator

GitHub → https://github.com/Indext-Data-Lab/windows-ui-synth

Need a fully integrated AI solution for your business? Reach out through the website or connect on LinkedIn

]]> Indext Stealth Launcher - Windows AI agent https://indext.io/tpost/g894auiz51-indext-stealth-launcher-windows-ai-agent https://indext.io/tpost/g894auiz51-indext-stealth-launcher-windows-ai-agent?amp=true Wed, 08 Apr 2026 12:23:00 +0300 A Windows app that turns Microsoft Edge into a programmable browser — and connects it to n8n via a local HTTP agent.

Indext Stealth Launcher - Windows AI agent

Computer-Vision Fallback for Windows UI Automation — Local UI Locator (Open Source)

Tag: Computer Vision · Windows Automation · Open Source · Python

The problem: when native UI APIs go silent

Windows UI automation is built on accessibility APIs. Libraries like pywinauto and UIAutomation query the element tree of an application — finding a button by name, reading its state, clicking it programmatically. In theory, this works universally. In practice, it breaks constantly.

Custom-rendered controls in Electron apps, legacy Win32 with owner-draw, dynamically injected popups, and aggressively themed enterprise software often expose no accessibility tree at all. The API returns nothing — just a flat window of pixels. Your automation agent is blind.

The classic fallback is template matching: take a screenshot, find a known image, click its center. But template matching breaks the moment DPI, theme, or window scale changes. What you actually need is a model that understands types of UI elements — buttons, text fields, dropdowns — so it can locate them even when they look slightly different from training data. That model needs to run locally, add under 100 ms to each step, and install with a single pip install. Local UI Locator was built for exactly this gap.

The solution: YOLO11s + OCR + fuzzy matching

Local UI Locator is a Python library that provides a computer-vision fallback layer for Windows UI agents. It activates when the accessibility tree returns nothing, takes a screenshot, and returns actionable click coordinates.

The pipeline has four stages:

Element detection. A YOLO11s model runs on the screenshot and returns bounding boxes with element type and confidence score. It detects seven classes: button, textbox, checkbox, dropdown, icon, tab, menu_item.

Text reading. EasyOCR reads visible text within each detected bounding box. No system dependencies — pure pip-installable, supports 80+ languages.

Fuzzy matching. rapidfuzz.fuzz.token_set_ratio matches OCR output against the agent's query string. Handles word reordering, partial labels, and minor OCR substitutions robustly. An agent looking for "Sign in" will match a button labeled "Signin" or "Sign In".

Action verification. Before/after screenshot comparison via pixel diff, OCR delta, or combined mode — confirms the click actually had effect.

Stack: YOLO11s (Ultralytics) · EasyOCR · rapidfuzz · Playwright (data generation) · FastAPI · Next.js · Gradio (demo)

Installation is one command — model weights download automatically from HuggingFace on first run:

pip install -e .

A quick integration into any automation agent looks like this:

from local_ui_locator import detect_elements, find_by_text, safe_click_point

# Detect all UI elements in a screenshot

detections = detect_elements("screenshot.png", conf=0.3)

for det in detections:

print(f"{det.type}: {det.bbox} (score={det.score:.2f})")

# Find a specific element by visible label

match = find_by_text("screenshot.png", query="Sign in")

if match:

x, y = safe_click_point(match.bbox)

print(f"Click at ({x}, {y})")

The library also ships a complete training pipeline. You can regenerate the synthetic dataset, retrain the model on your own UI styles, and evaluate — useful when your application uses a custom theme outside standard Windows 10/11 aesthetics.

Results: near-perfect detection across all seven classes

The model was trained on an NVIDIA RTX 5060 (8 GB, Blackwell) for 120 epochs with early stopping. The synthetic dataset of 3,000 Windows-style screenshots was generated entirely via HTML/CSS templates rendered with Playwright — no manual annotation.

Metric	Value
mAP@50	0.989
mAP@50–95	0.954
Precision	0.996
Recall	0.973
CPU inference (M2 Pro)	44–79 ms
GPU inference (RTX 5060)	2–5 ms

Class	AP@50
button	0.9919
textbox	0.9771
checkbox	0.9864
dropdown	0.9829
icon	0.9950
tab	0.9950
menu_item	0.9915

This represents a meaningful improvement over the prior YOLOv8n baseline (mAP@50 of 0.93) — a 6-point absolute gain — while keeping CPU inference under 80 ms. For a fallback layer that fires only when the accessibility tree is empty, that latency is acceptable.

The library ships with a Gradio demo that lets you upload any screenshot, adjust confidence threshold, filter by element class, and search elements by text — useful for validating behavior on your specific application before wiring it into an agent.

Why these specific components

YOLO11s over YOLOv8n. The accuracy gain from upgrading the backbone was significant: mAP@50 went from 0.93 to 0.989. Inference time roughly doubled on CPU (~30 ms to ~60 ms), but for a fallback layer that activates only on API failure, 60 ms is a reasonable trade-off.

EasyOCR over Tesseract. EasyOCR installs via pip with zero system dependencies. Tesseract requires system package installation and can be fragile in CI/CD environments. EasyOCR also returns word-level bounding boxes that intersect cleanly with the detector output.

Synthetic data via Playwright. Rendering HTML/CSS templates with Playwright gives exact bounding box coordinates from DOM queries — no manual annotation needed. Domain randomization across themes, fonts, DPI scaling, and noise was sufficient to achieve production-grade accuracy on real Windows UI despite training on entirely synthetic images.

Fuzzy matching via rapidfuzz. token_set_ratio handles partial label matches, word reordering, and minor OCR substitutions. Standard string equality would fail on the kind of OCR noise you see in real screenshots.

Known limitations

The model was trained on synthetic data only — real-world applications with heavily custom-styled controls may show a domain gap. It performs best on standard Windows 10 and 11 UI. The current release supports 7 element classes; complex widgets like date pickers, tree views, and data grids are not detected. Text content within elements is not provided by the detector — that requires the OCR layer explicitly. For non-standard applications, the included training pipeline makes it straightforward to generate additional data and fine-tune.

Source code and documentation →

➡️GitHub repository link

MIT License · Model weights on HuggingFace · Gradio demo included

]]>