Vision
chart understanding
graph extraction
data viz parsing

Chart & Graph Reading

Extracting data from charts, graphs, plots, and infographics. Specialized capability for vision-language models — distinct from raw OCR.

Capability notes

Chart reading — extracting structured data and semantic meaning from charts, graphs, and plots — is a multimodal LLM task with no viable specialized-model alternative in 2026. Open-weight VLMs (Qwen2.5-VL 72B, InternVL2-76B, Llama 3.2 Vision 90B) are the local path. Performance is benchmarked on ChartQA (question answering over charts) and Deplot (table extraction from charts). ChartQA human baseline: 80.5%. GPT-4V (cloud): 78.1%. Qwen2.5-VL 72B: 68.2% on ChartQA augmented split — reads bar/line/pie charts with 68% accuracy on numeric questions. InternVL2-76B: 71.3% — leads open-weight. Smaller VLMs (7B–13B) score 42–55% — numerically unreliable below ~30B parameters for chart work. Deplot accuracy (extracting data tables from charts): InternVL2-76B reconstructs bar chart tables with 82% cell accuracy, pie charts with 76%, scatter plots with 64%. Line charts with multiple series degrade to 58%. The failure pattern is consistent: VLMs read approximate values well (±5–10% error), struggle with exact values at chart edges, confuse similarly-colored series, and miss small data points. Multi-panel charts (dashboard views, trellis plots) compound errors — each panel loses 5–8% accuracy. Chart reading remains a VLM-solves-80%, human-verifies-the-rest task. For local deployment, the 72B–76B class models are the floor for production-acceptable accuracy. The open-weight gap to GPT-4V (78.1%) is ~7% — closing slowly with each VLM generation. Specialized Deplot-type models (Pix2Struct-based) exist but the VLM approach offers generalization to novel chart types that specialized models cannot match. For recommended models, see [Llama 3.3 70B](/models/llama-3-3-70b). Deploy locally with [Ollama](/tools/ollama) on [RTX 4090](/hardware/rtx-4090).

If you just want to try this

Lowest-friction path to a working setup.

Use [Ollama](/tools/ollama) with a vision-capable model for one-off chart reading. Install Ollama and pull: ```bash ollama pull llama3.2-vision:11b-instruct-q4_K_M ``` For a single chart screenshot, prompt with specific extraction instructions. The model responds best to structured output requests: ```python import requests, base64 with open("chart.png", "rb") as f: img = base64.b64encode(f.read()).decode() resp = requests.post("http://localhost:11434/api/generate", json={ "model": "llama3.2-vision:11b-instruct-q4_K_M", "prompt": "Extract the exact numeric values from this chart. Respond in JSON: " '{"chart_type": "...", "x_axis_label": "...", "y_axis_label": "...", ' '"data": [{"label": "...", "value": number}, ...]}. ' "Do not approximate. If a value is unclear, mark it as null.", "images": [img], "stream": False }) ``` The 11B VLM works for simple bar/line charts on [RTX 3060 12GB](/hardware/rtx-3060-12gb). For complex charts (multi-series, scatter, pie), you need a 32B+ model. [Llama 3.3 70B](/models/llama-3-3-70b) lacks vision — use Qwen2.5-VL 32B via [lm-studio](/tools/lm-studio) which has built-in vision model support with a simple GUI for image upload and prompt. For batch chart processing (10+ charts), install [Hugging Face Transformers](/tools/transformers) and use Qwen2.5-VL programmatically. Batch size 1 on [RTX 4090](/hardware/rtx-4090) at 32 GB runs 32B Qwen2.5-VL at 3–6 seconds per chart. The model returns structured answers when prompted with "Respond ONLY with a JSON array."

For production deployment

Operator-grade recommendation.

Production chart extraction at scale requires VLM serving infrastructure and post-processing validation. **Model selection.** InternVL2-76B leads open-weight ChartQA (71.3%). Qwen2.5-VL 72B follows (68.2%). Both require 48–80 GB VRAM at FP8. [InternVL2-76B on A100 80GB SXM](/hardware/nvidia-a100-80gb-sxm) at FP8: 2–4 seconds per chart. [Qwen2.5-VL 72B on H100 PCIe](/hardware/nvidia-h100-pcie) at FP8: 1.5–3 seconds per chart. Run via [vLLM](/tools/vllm) for continuous batching — achieves 8–15 concurrent requests on single 80 GB GPU. **Architecture.** Split pipeline: (1) chart detection and segmentation — identify chart regions in document images using a lightweight object detector; (2) VLM extraction — each chart region sent to VLM; (3) post-processing — validate extracted data against chart image (re-render from extracted numbers, compute SSIM against original). Each validation step catches ~60% of extraction errors. **Accuracy by chart type.** Bar charts: 80–88% cell accuracy (InternVL2-76B). Line charts single-series: 75–85%. Line charts multi-series (3+ lines): 65–78% — color confusion between series drops accuracy sharply. Pie charts with labels: 85–92% — labels provide text anchor for extraction. Pie charts without labels: 72–82%. Scatter plots: 55–68% — worst category, continuous value space confuses VLMs. Sankey, treemap, radar: 40–60% — novel chart types poorly represented in training data. **Cost analysis.** 10,000 charts/month via API (GPT-4V): $300–600. Local on [L40S](/hardware/nvidia-l40s) at ~$600/month rental: break-even at 10K charts. At 100K charts/month, local saves $3,000–5,000/month. For accuracy-critical workflows where charts contain financial or medical data, local additionally solves data residency. **Human-in-the-loop threshold.** For numeric data extraction where values underpin business decisions, VLM outputs require verification. Implement confidence scoring: when VLM reports low confidence (internal token probabilities show alternative values), flag for human review. Typical flag rate: 15–25% of charts.

What breaks

Failure modes operators see in the wild.

**Numeric hallucination.** Symptom: VLM extracts bar chart value as "157" when actual is "82." Cause: VLMs decode text autoregressively — numbers are token sequences, not mathematical values. The model reports a plausible-looking digit sequence with no arithmetic grounding. Mitigation: request structured JSON output with numeric type constraint (forces model to commit to digit sequence), run post-extraction validation — re-render chart from extracted values, compute SSIM >0.7 threshold, discard below threshold. **Color series confusion.** Symptom: multi-series line chart — VLM swaps "Revenue" and "Cost" series values. Cause: VLMs struggle with color-to-semantic mapping when colors are similar (blue vs teal, red vs orange). Mitigation: annotate chart images with series labels positioned adjacent to each line, use charts with distinct marker shapes per series, preprocess with color quantization to increase inter-series contrast. **Small element omission.** Symptom: chart has 12 bars but VLM extracts 9 — smallest bars missed entirely. Cause: small visual elements (bars <5% of chart height, thin lines, tiny data labels) are below VLM attention threshold after image downscaling to 448–980 px input resolution. Mitigation: input charts at minimum 1024×1024 resolution, crop multi-panel views into individual panels before extraction, prompt explicitly to "List ALL elements including smallest values." **Multi-panel degradation.** Symptom: dashboard with 4 chart panels — accuracy drops from 75% (single panel) to 45% (multi-panel). Cause: each panel receives fraction of VLM attention budget, smaller effective resolution per chart, labels from adjacent panels confuse context. Mitigation: pre-segment dashboard into individual chart images using edge detection or layout parsing before VLM extraction. Treat each panel as independent extraction task. **Log scale misreading.** Symptom: log-scale y-axis — VLM reports linear-scale values (10×, 100× errors). Cause: VLMs do not parse tick mark semantics — they match visual bar height to nearest axis label without detecting scale type. Mitigation: include scale type in prompt ("This chart uses a logarithmic y-axis"), train a binary classifier to detect log vs linear scale from axis markings, add explicit scale-validation step in pipeline.

Hardware guidance

**Hobbyist tier ($1,500–2,500).** [RTX 4090](/hardware/rtx-4090) at 24 GB: runs Qwen2.5-VL 7B at Q4 (fits easily) — 3–8 seconds per chart. Limited to bar/line/pie with ~55% ChartQA accuracy. Cannot fit 32B+ models required for production-adequate chart reading. [RTX 5090](/hardware/rtx-5090) at 32 GB: runs Qwen2.5-VL 32B at Q4 — 4–10 seconds per chart at 60–65% accuracy. The minimum single-consumer-GPU for production chart extraction. **SMB tier ($6,000–15,000).** [RTX 6000 Ada](/hardware/rtx-6000-ada) at 48 GB: runs InternVL2-76B at FP8 — 3–7 seconds per chart at 68–71% accuracy. Fits model + KV cache for 4–8 concurrent requests. [L40S](/hardware/nvidia-l40s) at 48 GB: identical profile with better sustained thermals for 24/7 operation. **Enterprise tier ($25,000+).** [A100 80GB SXM](/hardware/nvidia-a100-80gb-sxm): InternVL2-76B at FP16 — 2–4 seconds per chart at full accuracy. Handles batch=4 at 8 concurrent requests. [H200](/hardware/nvidia-h200) at 141 GB: fits InternVL2-76B or Qwen2.5-VL 72B with 32K+ context and 20+ concurrent sessions. [AMD MI300X](/hardware/amd-mi300x) at 192 GB: fits largest VLMs at FP16 with headroom for large-context chart extraction (multi-page reports with 50+ charts). **Apple Silicon.** [MacBook Pro 16" M4 Max](/hardware/macbook-pro-16-m4-max) at 128 GB: Qwen2.5-VL 72B at Q4 via [MLX-LM](/tools/mlx-lm) — 8–15 seconds per chart. Viable for <100 charts/day batch processing. [Mac Studio M3 Ultra](/hardware/mac-studio-m3-ultra) at 192 GB: InternVL2-76B at Q4 — 5–10 seconds per chart, handles 20+ concurrent without offloading. **Resolution impact.** Chart reading accuracy scales with input resolution. 224×224: 30–40% accuracy (unusable). 448×448: 55–65%. 980×980: 65–75%. The VLM architecture resizes images to a fixed grid before encoding — 980 px is Qwen2.5-VL's default. Models with dynamic resolution (InternVL2) can process up to 4480×4480 across multiple tiles, improving small-element detection at 2–3× VRAM cost.

Runtime guidance

**Ollama vs Transformers vs vLLM — chart extraction pipeline selection.** [Ollama](/tools/ollama) provides the simplest path for ad-hoc chart reading. Vision model support (`llama3.2-vision`, `llava`, `minicpm-v`) works out of the box. API accepts base64-encoded images alongside prompt text. Limitation: single-request model — no batching, no prefix caching. Use for <50 charts/day or interactive use. [Hugging Face Transformers](/tools/transformers) loads Qwen2.5-VL and InternVL2 with standard `AutoModelForVision2Seq` API. Enables batch processing via Python loops but no built-in serving. For batch chart processing (50–500 charts/day), use Transformers with manual GPU scheduling — preprocess chart images to disk, load model once, iterate through images with `model.generate()`. On [RTX 6000 Ada](/hardware/rtx-6000-ada), 500 charts at 5 seconds each = 42 minutes total batch time. [LM Studio](/tools/lm-studio) supports vision models in its GUI — upload image, type prompt, get extraction. Simplest possible workflow for non-technical users performing occasional chart reading. Supports llama3.2-vision, Qwen2.5-VL, Pixtral. Runs on Windows/macOS/Linux with GPU auto-detection. [vLLM](/tools/vllm) with vision model support provides production serving: continuous batching, prefix caching, OpenAI-compatible API. Prefix caching reuses vision encoder outputs when the same chart is queried with multiple prompts — useful for multi-question extraction (extract title, data, axis labels, legend — 4 separate prompts on same chart). On [A100 80GB](/hardware/nvidia-a100-80gb-sxm), serves 8–15 concurrent chart extraction requests at 2–5 seconds each. **Post-extraction validation.** After VLM extraction, run validation: (1) numeric sanity — check that values are within chart's axis range; (2) count consistency — number of extracted data points should match number of visible chart elements (detected via edge counting); (3) re-render and compare — matplotlib re-render of extracted data, compute SSIM >0.7 against original chart. Validation pipeline adds 0.5–1 second per chart but catches 55–70% of extraction errors.

Setup walkthrough

  1. Install Ollama → ollama pull minicpm-v (~8 GB — strong multimodal model with chart understanding).
  2. Save a chart image (bar chart, line graph, pie chart) as chart.png.
  3. Python script:
import ollama
with open("chart.png", "rb") as f:
    img_data = f.read()
resp = ollama.chat(model="minicpm-v", messages=[{
    "role": "user", "content": "Extract all data points from this chart. What is the X axis? Y axis? Give me the approximate values for each data series.",
    "images": [img_data]
}])
print(resp["message"]["content"])
  1. First chart reading in 5-15 seconds. For better accuracy: ollama pull qwen2.5-vl:7b — stronger chart understanding, 128K context, handles multi-chart documents.
  2. For programmatic chart data extraction: pip install deplot (Google's DePlot — chart-to-table model, SOTA for simple charts).

The cheap setup

Used RTX 3060 12 GB (~$200-250, see /hardware/rtx-3060-12gb). Runs MiniCPM-V 8B at 5-10 seconds per chart. Qwen2-VL 7B at 5-15 seconds per chart. Handles bar charts, line plots, scatter plots, and simple pie charts with reasonable accuracy. Pair with Ryzen 5 5600 + 16 GB DDR4 + 512 GB NVMe. Total: ~$360-405. Chart reading is viable at this budget — the models run comfortably in 12 GB. For DePlot (pixel-to-table mapping without LLM overhead): it runs on CPU at 1-3 seconds per chart.

The serious setup

Used RTX 3090 24 GB ($700-900, see /hardware/rtx-3090). Runs Qwen2-VL 72B at 10-20 seconds per chart (50 GB, needs quantized). The 72B variant handles complex charts (multi-axis, stacked bars, logarithmic scales) with near-human accuracy. For batch chart processing (100s of charts/day): the 7B-8B models at 2-5 seconds per chart via vLLM are the throughput play. Total: ~$1,800-2,200. Chart reading benefits more from model quality than GPU speed — a 72B model on 3090 is more accurate than a 7B model on 4090.

Common beginner mistake

The mistake: Using a text-only LLM (with OCR pre-processing) to "read" charts by extracting axis labels and guessing values. Why it fails: Text-only LLMs can't see spatial relationships — they can't understand that the bar height maps to the Y-axis scale, or that a scatter plot's trend line means correlation. OCR extracts "Sales: 100, 200, 300" but can't tell which bar is which. The fix: Use a vision-language model (MiniCPM-V, Qwen2-VL, or DePlot). These models see the actual chart image and understand visual encodings (position, length, area, color). They correctly extract data because they process the chart as pixels, not text. If you need structured output (CSV/JSON), use DePlot — it's trained specifically for chart-to-table conversion.

Recommended setup for chart & graph reading

Recommended runtimes

Browse all tools for runtimes that fit this workload.

Reality check

Local AI workloads have real hardware constraints that vary by task type. VRAM ceiling decides what model fits; bandwidth decides decode speed; compute decides prefill speed. Pick the GPU tier that fits your actual workload, not the spec sheet.

Common mistakes

  • Buying for spec-sheet VRAM without modeling KV cache + activation overhead
  • Underestimating quantization quality loss below Q4
  • Skipping flash-attention support (real perf gap on long context)
  • Ignoring sustained-load thermals (laptops thermal-throttle within 30 min)

What breaks first

The errors most operators hit when running chart & graph reading locally. Each links to a diagnose+fix walkthrough.

Before you buy

Verify your specific hardware can handle chart & graph reading before committing money.

Specialized buyer guides
Updated 2026 roundup