Data Visualization & Pattern Detection

Why Visualise Data? 👀Data को Visualise क्यों करें? 👀为什么要可视化数据？👀

Numbers alone rarely tell the full story. A table of ten thousand rows can hide a straight-line trend, a cluster of odd values, or a seasonal spike. You do not see them until you plot. A chart turns numbers into shape, colour and position — things the eye reads very fast.

सिर्फ़ संख्याएँ पूरी कहानी कम ही बताती हैं। दस हज़ार rows की table में सीधी-रेखा वाला trend, अजीब मानों का झुंड, या मौसमी उछाल छिपा हो सकता है। Plot करने से पहले वे दिखते नहीं। Chart संख्याओं को आकार, रंग और जगह में बदल देता है — ऐसी चीज़ें जिन्हें आँख बहुत तेज़ी से पढ़ती है।

光看数字很少能讲清全部故事。一张一万行的表格里，可能藏着一条直线趋势、一簇异常值或一次季节性高峰 —— 不画图就看不见。图表把数字变成形状、颜色和位置，而这些正是眼睛读得最快的东西。

# 1) Anscombe's quartet: the numbers agree, the pictures do not
import numpy as np
x = [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5]
ys = {"I":   [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68],
      "II":  [9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74],
      "III": [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73],
      "IV":  [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89]}
x4 = [8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8]
for k, y in ys.items():
    xx = np.array(x4 if k == "IV" else x); y = np.array(y)
    slope, icpt = np.polyfit(xx, y, 1)
    print(f"{k:>3}: mean x {xx.mean():.2f}  var x {xx.var(ddof=1):.2f}  mean y {y.mean():.2f}  "
          f"var y {y.var(ddof=1):.2f}  r {np.corrcoef(xx, y)[0, 1]:.3f}  line y = {icpt:.2f} + {slope:.3f}x")

In 2017, Justin Matejka and George Fitzmaurice took the idea further with the "Datasaurus Dozen": they moved points step by step, keeping the statistics fixed to 2 decimals, until the cloud turned into a dinosaur, a star or a circle. The simulator below does the same thing live.

2017 में Justin Matejka और George Fitzmaurice ने यह विचार "Datasaurus Dozen" से आगे बढ़ाया: उन्होंने points को क़दम-दर-क़दम खिसकाया, statistics को 2 दशमलव तक स्थिर रखते हुए, जब तक बादल dinosaur, तारा या वृत्त नहीं बन गया। नीचे का simulator यही काम live करता है।

2017 年，Justin Matejka 和 George Fitzmaurice 用“Datasaurus Dozen”把这个思想推进了一步：他们一步步移动数据点，同时把统计量固定在 2 位小数，直到点云变成恐龙、星形或圆。下面的模拟器现场演示同样的过程。

Choosing the Right Chart 🧭सही Chart चुनना 🧭选择合适的图表 🧭

Every chart type answers a certain kind of question. Start from the question, not from what looks nice.

हर chart type एक ख़ास तरह के सवाल का जवाब देता है। सवाल से शुरू करें, सुंदर दिखने से नहीं।

每种图表都回答某一类问题。从问题出发，而不是从好不好看出发。

Distribution Plots — Understanding Shape 📊Distribution Plots — आकार समझना 📊分布图 —— 理解形状 📊

Before any model, look at how each numeric variable is spread out. Distribution plots show the centre, the spread, the skew and the odd values at a glance. All pictures in this tutorial come from two practice datasets made in Section 9: customers.csv (2,000 customers) and daily_sales.csv (2 years of daily revenue).

किसी भी model से पहले देखें कि हर numeric variable कैसे फैला है। Distribution plots एक नज़र में केंद्र, फैलाव, skew और अजीब मान दिखाते हैं। इस tutorial की सभी तस्वीरें Section 9 में बने दो practice datasets से हैं: customers.csv (2,000 ग्राहक) और daily_sales.csv (2 साल की रोज़ की revenue)।

建模之前，先看每个数值变量是如何分布的。分布图能一眼看出中心、离散程度、偏态和异常值。本教程所有图都来自第 9 节生成的两个练习数据集：customers.csv（2,000 位顾客）和 daily_sales.csv（两年的每日收入）。

Histogram with KDEKDE के साथ Histogram直方图与 KDE

A histogram cuts the range into bins and counts the values in each bin. A KDE (kernel density estimate) puts a small smooth bump on every value and adds them up, giving a smooth curve. Both depend on a setting you choose: the number of bins, and the KDE bandwidth.

Histogram range को bins में काटता है और हर bin के मान गिनता है। KDE (kernel density estimate) हर मान पर एक छोटा चिकना उभार रखता है और उन्हें जोड़ देता है, जिससे चिकना curve बनता है। दोनों आपकी चुनी setting पर निर्भर हैं: bins की संख्या, और KDE bandwidth।

直方图把取值范围切成若干区间（bin），统计每个区间里的值。KDE（核密度估计）在每个值上放一个小的平滑“鼓包”，再把它们加起来，得到一条平滑曲线。两者都取决于你选的设置：分组数和 KDE 带宽。

Box Plot — Spread and OutliersBox Plot — फैलाव और Outliers箱线图 —— 离散与异常值

# 2) Distributions: histogram + KDE, box plots by category
import pandas as pd, seaborn as sns, matplotlib
matplotlib.use("Agg"); import matplotlib.pyplot as plt
df = pd.read_csv("customers.csv")

fig, ax = plt.subplots(1, 2, figsize=(11, 4))
sns.histplot(df["purchase_amount"], bins=40, kde=True, ax=ax[0])
sns.boxplot(data=df, x="product_category", y="purchase_amount",
            hue="product_category", legend=False, ax=ax[1])   # seaborn 0.13: give hue when you set colours
fig.savefig("dist.png", dpi=80)

s = df["purchase_amount"]
print(f"mean {s.mean():,.0f}  median {s.median():,.0f}  skew {s.skew():.2f}")
print(df.groupby("product_category")["purchase_amount"].quantile([.25, .5, .75]).unstack().round(-1))

Relationship Plots — Finding Connections 🔗Relationship Plots — संबंध खोजना 🔗关系图 —— 寻找关联 🔗

Relationship plots show how two or more variables move together. They help you pick useful features — but a link you see is a clue, not proof that one thing causes the other.

Relationship plots दिखाते हैं कि दो या ज़्यादा variables साथ-साथ कैसे चलते हैं। ये काम के features चुनने में मदद करते हैं — पर दिखा हुआ संबंध एक सुराग है, यह सबूत नहीं कि एक चीज़ दूसरी की वजह है।

关系图展示两个或多个变量如何一起变化。它们能帮你挑选有用的特征 —— 但看到的关联只是线索，不能证明一件事导致了另一件事。

Scatter Plot with Colour for GroupsGroups के लिए रंग वाला Scatter Plot用颜色区分组的散点图

Correlation HeatmapCorrelation Heatmap相关热力图

A heatmap of the correlation matrix shows every pairwise Pearson correlation as a coloured cell. Hide the upper half with a mask — it only repeats the lower half.

Correlation matrix का heatmap हर जोड़ी का Pearson correlation एक रंगीन cell के रूप में दिखाता है। ऊपरी आधा mask से छिपाएँ — वह सिर्फ़ निचले आधे को दोहराता है।

相关矩阵热力图把每一对变量的 Pearson 相关系数显示为一个彩色格子。用 mask 隐藏上半部分 —— 它只是下半部分的重复。

# 3) Relationships: scatter with colour, and a correlation heatmap
import numpy as np, pandas as pd, seaborn as sns, matplotlib
matplotlib.use("Agg"); import matplotlib.pyplot as plt
df = pd.read_csv("customers.csv")

sns.scatterplot(data=df, x="age", y="purchase_amount", hue="income_bracket",
                hue_order=["Low", "Medium", "High", "Very High"], alpha=0.6)
plt.yscale("log"); plt.savefig("scatter.png", dpi=80); plt.close()

corr = df.select_dtypes("number").corr().round(2)
mask = np.triu(np.ones_like(corr, dtype=bool))            # hide the repeated upper half
sns.heatmap(corr, mask=mask, annot=True, fmt=".2f", cmap="coolwarm", center=0, vmin=-1, vmax=1)
plt.savefig("heatmap.png", dpi=80)
print(corr)

Time Series Visualisation 📈Time Series Visualisation 📈时间序列可视化 📈

A time series plot answers three questions at once: Is there a trend? Is there seasonality? Are there sudden spikes or drops? Daily data is noisy, so we add a rolling mean to see the trend. Use a rolling mean on daily (or weekly) points — a "7-day rolling mean" only makes sense when each point is one day.

Time series plot एक साथ तीन सवालों का जवाब देता है: क्या कोई trend है? क्या seasonality है? क्या अचानक उछाल या गिरावट है? रोज़ का data शोर भरा होता है, इसलिए trend देखने के लिए rolling mean जोड़ते हैं। Rolling mean रोज़ के (या हफ़्ते के) points पर लगाएँ — "7-day rolling mean" का मतलब तभी है जब हर point एक दिन हो।

时间序列图同时回答三个问题：有没有趋势？有没有季节性？有没有突然的峰值或骤降？日数据噪声大，所以要加滚动均值来看趋势。滚动均值要用在日（或周）数据上 —— 只有每个点代表一天时，“7 日滚动均值”才有意义。

Identifying Patterns in Data 🧩Data में Patterns पहचानना 🧩识别数据中的规律 🧩

A pattern is anything that repeats, lasts, or follows a rule. Three kinds matter most in data science.

Pattern वह चीज़ है जो दोहराती है, टिकी रहती है, या किसी नियम पर चलती है। Data science में तीन तरह के सबसे ज़रूरी हैं।

规律是任何会重复、会持续或遵循某种规则的东西。数据科学中最重要的有三类。

Spotting Anomalies Visually 🚨Anomalies को देखकर पहचानना 🚨用图发现异常 🚨

An anomaly is a point that does not fit the expected pattern. It may be a data error, a real extreme value, or a real signal — a sale, a fraud attempt, a system outage. Charts are a fast way to find them; deciding what they mean needs domain knowledge.

Anomaly ऐसा point है जो अपेक्षित pattern में फ़िट नहीं होता। यह data की ग़लती, असली अति मान, या असली संकेत हो सकता है — कोई sale, fraud की कोशिश, system outage। Charts इन्हें ढूँढने का तेज़ तरीक़ा हैं; इनका मतलब तय करने के लिए domain knowledge चाहिए।

异常是不符合预期模式的点。它可能是数据错误、真实的极端值，也可能是真实信号 —— 一次促销、一次欺诈尝试、一次系统宕机。图表能快速发现它们；判断它们的含义则需要领域知识。

# 4) Time series: rolling mean, monthly pattern, and spike detection
import pandas as pd
daily = pd.read_csv("daily_sales.csv", parse_dates=["date"]).set_index("date")

daily["rolling_7d"] = daily["revenue"].rolling(7).mean()
monthly = daily["revenue"].groupby(daily.index.month).mean().round(1)
print("average daily revenue by month (₹k):"); print(monthly.to_string())

# Control band from the PREVIOUS 28 days (shift(1) keeps today's value out of its own band)
base = daily["revenue"].shift(1).rolling(28)
daily["upper"] = base.mean() + 3 * base.std()
daily["lower"] = base.mean() - 3 * base.std()
spikes = daily[(daily["revenue"] > daily["upper"]) | (daily["revenue"] < daily["lower"])]
print("\nflagged days:"); print(spikes[["revenue", "lower", "upper"]].round(1))

For people who are not coders, an interactive chart helps: they can hover over a red marker to see the date and value. plotly does this in a few lines:

जो लोग coder नहीं हैं, उनके लिए interactive chart मदद करता है: वे लाल marker पर hover करके date और मान देख सकते हैं। plotly यह कुछ lines में करता है:

对于不写代码的人，交互式图表很有帮助：鼠标悬停在红色标记上就能看到日期和数值。plotly 只需几行即可做到：

# 5) An interactive chart for stakeholders: plotly line + red markers on flagged days
import pandas as pd, plotly.graph_objects as go
daily = pd.read_csv("daily_sales.csv", parse_dates=["date"]).set_index("date")
base = daily["revenue"].shift(1).rolling(28)
daily["upper"] = base.mean() + 3 * base.std()
daily["lower"] = base.mean() - 3 * base.std()
flag = (daily["revenue"] > daily["upper"]) | (daily["revenue"] < daily["lower"])

fig = go.Figure()
fig.add_scatter(x=daily.index, y=daily["upper"], line_width=0, showlegend=False)
fig.add_scatter(x=daily.index, y=daily["lower"], fill="tonexty", line_width=0, name="normal band")
fig.add_scatter(x=daily.index, y=daily["revenue"], name="revenue", line_width=1)
fig.add_scatter(x=daily.index[flag], y=daily["revenue"][flag], mode="markers",
                marker=dict(color="red", size=9), name="flagged")
fig.update_layout(title="Daily revenue (₹ thousand)", hovermode="x unified")
fig.write_html("revenue.html")          # open in a browser: hover, zoom, pan
print("flagged:", int(flag.sum()), "days   traces:", len(fig.data))

Honest Charts — How Charts Mislead 🎭ईमानदार Charts — Charts कैसे भटकाते हैं 🎭诚实的图表 —— 图表如何误导 🎭

The same numbers can tell different stories depending on how they are drawn. Most misleading charts are accidents, not tricks: a default axis, a pie with too many slices, or colours that some readers cannot tell apart.

एक ही संख्याएँ इस पर निर्भर करते हुए अलग कहानियाँ बता सकती हैं कि उन्हें कैसे बनाया गया। ज़्यादातर भटकाने वाले charts चाल नहीं, भूल होते हैं: default axis, बहुत सारे टुकड़ों वाला pie, या ऐसे रंग जिन्हें कुछ पाठक अलग नहीं कर पाते।

同样的数字，画法不同，讲出的故事也不同。大多数误导性图表是无心之失，而不是故意：默认的坐标轴、切片太多的饼图，或部分读者分不清的颜色。

Make the Practice Data Yourself 🐍Practice Data ख़ुद बनाएँ 🐍自己生成练习数据 🐍

Every chart above was drawn from these two files. The patterns (age → income, category → spend, delivery → rating, trend, weekly and festive seasonality, three one-day anomalies) are built in on purpose, so you can check that each chart finds them. Run this first, then the code blocks in Sections 1–7.

ऊपर का हर chart इन दो files से बना है। Patterns (age → income, category → ख़र्च, delivery → rating, trend, साप्ताहिक और त्योहारी seasonality, तीन एक-दिन की anomalies) जानबूझकर डाले गए हैं, ताकि आप जाँच सकें कि हर chart उन्हें ढूँढता है। पहले इसे चलाएँ, फिर Sections 1–7 के code blocks।

上面每张图都来自这两个文件。其中的规律（年龄 → 收入、类别 → 消费、配送 → 评分、趋势、周和节日季节性、三个单日异常）都是有意内置的，这样你可以检验每张图能否找到它们。先运行这段代码，再运行第 1–7 节的代码块。

# 0) Build two practice datasets that contain real patterns to find
import numpy as np, pandas as pd
rng = np.random.default_rng(11)

# --- customers.csv: one row per customer ---
n = 2000
age = rng.integers(18, 66, n)
p_hi = np.clip((age - 18) / 60, 0.05, 0.75)                 # older -> more likely higher income
income_code = np.minimum(3, rng.binomial(3, p_hi))
brackets = np.array(["Low", "Medium", "High", "Very High"])
cats = rng.choice(["Electronics", "Furniture", "Clothing", "Books", "Grocery"], n, p=[.15, .1, .3, .2, .25])
cat_base = pd.Series({"Electronics": 9.0, "Furniture": 8.7, "Clothing": 7.9, "Books": 7.0, "Grocery": 6.3})[cats].to_numpy()
spend = np.exp(cat_base + 0.35 * income_code + rng.normal(0, 0.45, n)).round(-1)
delivery = rng.integers(1, 11, n)
rating = np.clip(np.round(5.2 - 0.28 * delivery + rng.normal(0, 0.8, n)), 1, 5)
pd.DataFrame({"age": age, "income_bracket": brackets[income_code], "income_code": income_code,
              "product_category": cats, "purchase_amount": spend,
              "delivery_days": delivery, "rating": rating}).to_csv("customers.csv", index=False)

# --- daily_sales.csv: two years of daily revenue (₹ thousand) ---
days = pd.date_range("2024-01-01", "2025-12-31", freq="D")
t = np.arange(len(days))
trend = 40 + 20 * t / len(days)
weekly = np.where(days.dayofweek >= 5, 1.18, 1.0)
festive = 1 + 0.45 * np.exp(-((days.dayofyear - 305) / 18) ** 2) + 0.25 * np.exp(-((days.dayofyear - 358) / 6) ** 2)
revenue = np.asarray(trend * weekly * festive * rng.normal(1, 0.07, len(days)))
for d, f in [("2024-03-15", 2.2), ("2025-02-01", 5.0), ("2025-06-10", 0.2)]:   # flash sale, data error, outage
    revenue[days.get_loc(d)] *= f
pd.DataFrame({"date": days, "revenue": revenue.round(2)}).to_csv("daily_sales.csv", index=False)
print("customers.csv:", n, "rows   daily_sales.csv:", len(days), "rows")

Golden Rules of Data Visualisation 🏆Data Visualisation के सुनहरे नियम 🏆数据可视化黄金法则 🏆