Understanding Vision Transforemer With Storytelling in Hindi

Vision Transformers as Civilization

भाग 1: दृष्टि-संस्कृति का उदय

---

प्रस्तावना: जब देखने ने सोचना सीखा

कहते हैं, सभ्यताएँ तब जन्म लेती हैं जब मनुष्य केवल देखना नहीं, समझना सीख जाता है।
पर एक ऐसी भी सभ्यता थी—जहाँ देखने की कला को ही विचार का दर्जा दे दिया गया।
उस सभ्यता का नाम था — दृष्टि-संस्कृति।

यह कथा उसी की है।

---

अध्याय 1: अखंड दृश्य का संकट

सम्राट अद्वैत के साम्राज्य में सब कुछ था—पर्वत, नदियाँ, नगर, वन, मरुस्थल।
पर एक समस्या थी।

कोई भी चित्रकार जब इस साम्राज्य का मानचित्र बनाता, तो या तो वह बारीकियों में खो जाता, या समग्रता में।

किसी को संपूर्णता समझ नहीं आती थी।

सभा में एक युवा चिंतक आया—विहान।

उसने कहा:

“महाराज, समस्या दृष्टि की सीमा में नहीं, पद्धति की जड़ता में है।
हम सम्पूर्ण को एक साथ पकड़ना चाहते हैं,
जबकि समझ टुकड़ों के संवाद से जन्म लेती है।”

सभा मौन हो गई।

---

अध्याय 2: विभाजन का विधान

विहान ने विशाल कैनवास भूमि पर फैलाया।

उसने उसे एक साथ चित्रित नहीं किया।

उसने उसे बाँट दिया।

समान आकार के वर्गों में।

हर वर्ग—एक संसार।
हर टुकड़ा—एक कथा।

विहान ने घोषणा की:

“अब कोई भी इस साम्राज्य को एक साथ नहीं देखेगा।
हर कोई एक छोटे से भाग को समझेगा।
और फिर हम उन समझों को मिलाएँगे।”

इस विभाजन में विनाश नहीं था।
यह बोध का अनुशासन था।

---

अध्याय 3: रूपांतरण का संस्कार

पर विहान जानता था—ये टुकड़े अभी कच्चे हैं।

उन्होंने रंग तो देखे हैं, पर भाषा नहीं सीखी।

इसलिए हर टुकड़े को राजसभा की प्रयोगशाला में ले जाया गया।
वहाँ उन्हें एक नई भाषा में बदला गया।

उनके रंग, उनकी रेखाएँ, उनकी गहराई—
सबको संक्षिप्त सूत्रों में परिवर्तित किया गया।

अब हर टुकड़ा एक वाक्य था।

चित्र अब विचार बन चुका था।

---

अध्याय 4: स्थान की स्मृति

पर समस्या अभी शेष थी।

यदि इन वाक्यों का क्रम बदल जाए,
तो अर्थ बदल जाएगा।

विहान ने प्रत्येक टुकड़े के पीछे एक अदृश्य अंकन कर दिया।
यह अंकन बताता था—

“तुम उत्तर के हो।”
“तुम नदी के किनारे से आए हो।”
“तुम पहाड़ की ढलान का अंश हो।”

यह स्थान की स्मृति थी।

बिना स्मृति, ज्ञान दिशाहीन हो जाता है।

---

अध्याय 5: संवाद-संस्कृति का आरंभ

अब वह क्षण आया जिसने दृष्टि-संस्कृति को जन्म दिया।

एक विशाल गोलाकार सभा बनाई गई।

सभी टुकड़े—अब विचारों के रूप में—वहाँ रखे गए।

विहान ने नियम घोषित किया:

“कोई भी अकेला सत्य नहीं है।
हर टुकड़ा हर दूसरे से पूछेगा—
तुम मेरे लिए कितने महत्वपूर्ण हो?”

सभा में हलचल हुई।

एक नीला टुकड़ा बोला:

“क्या कोई तट है जो मुझे अर्थ देता है?”

एक भूरे रंग का टुकड़ा उत्तर देता है:

“मैं हूँ—मैं तुम्हारी सीमा हूँ।”

एक हरा टुकड़ा कहता है:

“मेरे बिना वर्षा का अर्थ नहीं।”

और इस प्रकार—

संबंधों के धागे खिंचने लगे।

कुछ धागे सुनहरे थे—गहरे संबंध।
कुछ धुंधले—सतही जुड़ाव।

सभा अब एक जाल थी।
एक जीवित तंत्र।

यह था—संवाद का विज्ञान।

---

अध्याय 6: बहु-दृष्टि परिषद

विहान ने देखा—एक दृष्टि पर्याप्त नहीं।

उसने परिषद बनाई।

एक समूह रंगों के संबंध देखता था।
एक समूह आकृतियों के।
एक दूरी के पैमाने पर सोचता था।
एक भावनात्मक संतुलन देखता था।

एक ही दृश्य—अनेक व्याख्याएँ।

सत्य अब बहुवचन में था।

---

अध्याय 7: शोधन की भट्टी

संवाद के पश्चात, हर टुकड़े के पास अपार जानकारी थी।

पर जानकारी ज्ञान नहीं होती।

उन्हें एक-एक कर शोधन-भट्टी में भेजा गया।

भट्टी में उनका विस्तार होता—
वे अपने भीतर के अर्थों को फैलाते।

फिर उन्हें दबाया जाता—
सार निकाला जाता।

कच्चा अनुभव → परिष्कृत समझ।

यह प्रक्रिया बार-बार दोहराई गई।

संवाद।
शोधन।
संवाद।
शोधन।

परत-दर-परत।

सभ्यता गहरी होती गई।

---

अध्याय 8: अभ्यास का युग (प्रशिक्षण)

पर सम्राट ने पूछा—

“क्या यह प्रणाली हर साम्राज्य को समझ सकती है?”

विहान मुस्कुराया।

“नहीं महाराज। इसे सीखना होगा।”

तब शुरू हुआ अभ्यास का युग।

हजारों मानचित्र लाए गए।

हर मानचित्र के साथ एक सत्य जुड़ा था:

“यह वन-प्रधान है।”
“यह जल-समृद्ध है।”
“यह मरुस्थलीय है।”

दृष्टि-संस्कृति ने अनुमान लगाए।

पहले वह भूल करती थी।

तब राजगुरु उसे सुधारते थे।

गलत उत्तर → दंड नहीं, संशोधन।

प्रत्येक त्रुटि के बाद—
सभ्यता अपने संबंधों को थोड़ा बदलती।

कुछ धागे मोटे होते।
कुछ कट जाते।

धीरे-धीरे—

वह अनुमान से अधिक सटीक होने लगी।

यह था—अनुभव से संशोधन का युग।

---

अध्याय 9: स्थिरता का विधान

जब अभ्यास पूर्ण हुआ,
सभ्यता स्थिर हो गई।

अब संबंध स्थायी थे।

अब नए मानचित्र आते।

सभा होती।
संवाद होता।
शोधन होता।
और अंतिम दूत निर्णय सुनाता।

पर अब कोई संशोधन नहीं होता।

यह था—निर्णय का काल।

---

अध्याय 10: अंतिम दूत

सभा के मध्य एक अद्भुत तत्व था।

एक ऐसा टुकड़ा जिसका अपना कोई चित्र नहीं था।

वह केवल सुनता था।

सबसे संवाद करता।
सबकी रिपोर्ट लेता।

अंत में वही सम्राट के सामने खड़ा होता।

वह कहता:

“यह दृश्य जल-प्रधान है।”
“यह पर्वतीय है।”
“यह समृद्ध है।”

सम्राट चकित होते।

उन्हें नहीं दिखता था जो उस दूत को दिखता था।

---

उपसंहार: दृष्टि का दर्शन

वर्षों बाद,

जब विहान वृद्ध हो चुका था,
उससे पूछा गया—

“तुमने यह सब कैसे रचा?”

वह बोला:

“मैंने कुछ नया नहीं बनाया।
मैंने केवल हर हिस्से को
हर दूसरे हिस्से से बात करने दिया।
सत्य स्वयं प्रकट हो गया।”

और यही दृष्टि-संस्कृति की विरासत बनी।

जहाँ देखना केवल पिक्सेल नहीं रहा,
बल्कि संबंधों की चेतना बन गया।

---

Vision Transformers as Civilization — डिकोडिंग

कहानी से कोड तक: पूरी Training + Inference Pipeline

अब हम पूरी सभ्यता को तकनीकी रूप में पुनर्निर्मित करेंगे।

हम हर अध्याय को कोड में बदलेंगे।

---

🏛 अध्याय → Architecture Mapping

कहानी	ViT Component
टुकड़ों में विभाजन	Patch Embedding
भाषा में रूपांतरण	Linear Projection
स्थान की स्मृति	Positional Embedding
बहु-दृष्टि परिषद	Multi-Head Self Attention
शोधन भट्टी	MLP Block
संवाद + शोधन की परतें	Transformer Encoder Layers
अंतिम दूत	CLS Token
अभ्यास का युग	Training Loop
स्थिर निर्णय	Inference

---

🧱 STEP 1: विभाजन का विधान (Patch Embedding)

कहानी में:

साम्राज्य को समान वर्गों में बाँटा गया।

तकनीकी रूप:

Image: (B, C, H, W)
Patch size: P x P

import torch
import torch.nn as nn

class PatchEmbedding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768):
        super().__init__()

        self.patch_size = patch_size
        self.num_patches = (img_size // patch_size) ** 2

        # Linear Projection using Conv
        self.proj = nn.Conv2d(
            in_channels,
            embed_dim,
            kernel_size=patch_size,
            stride=patch_size
        )

    def forward(self, x):
        x = self.proj(x)              # (B, embed_dim, H/P, W/P)
        x = x.flatten(2)              # (B, embed_dim, N)
        x = x.transpose(1, 2)         # (B, N, embed_dim)
        return x

🧠 क्या हुआ?

• Conv2d यहाँ flatten + linear दोनों कर रहा है।
• हर patch → 768 dimension vector।
• अब हर टुकड़ा “विचार” बन गया।

---

🏷 STEP 2: स्थान की स्मृति (Positional Embedding)

कहानी में:

हर टुकड़े के पीछे अंकन।

class PositionalEmbedding(nn.Module):
    def __init__(self, num_patches, embed_dim):
        super().__init__()
        self.pos_embedding = nn.Parameter(
            torch.randn(1, num_patches + 1, embed_dim)
        )

    def forward(self, x):
        return x + self.pos_embedding

+1 क्यों?

👉 क्योंकि हमें CLS token भी जोड़ना है।

---

👑 STEP 3: अंतिम दूत (CLS Token)

class CLSToken(nn.Module):
    def __init__(self, embed_dim):
        super().__init__()
        self.cls_token = nn.Parameter(torch.randn(1, 1, embed_dim))

    def forward(self, x):
        B = x.size(0)
        cls_tokens = self.cls_token.expand(B, -1, -1)
        return torch.cat((cls_tokens, x), dim=1)

अब sequence shape:

(B, N+1, embed_dim)

CLS = सभा का केंद्रीय दूत

---

🧠 STEP 4: बहु-दृष्टि परिषद (Multi-Head Self Attention)

कहानी में:

हर टुकड़ा पूछता है — तुम मेरे लिए कितने महत्वपूर्ण हो?

Mathematically:

[
Attention(Q,K,V) = softmax(QK^T / \sqrt{d}) V
]

PyTorch:

class MultiHeadSelfAttention(nn.Module):
    def __init__(self, embed_dim=768, num_heads=12):
        super().__init__()

        self.attn = nn.MultiheadAttention(
            embed_dim,
            num_heads,
            batch_first=True
        )

    def forward(self, x):
        attn_output, _ = self.attn(x, x, x)
        return attn_output

यहाँ:

• Q = K = V = x
• इसलिए इसे Self-Attention कहते हैं।

यहाँ धागे बन रहे हैं।

---

🔥 STEP 5: शोधन भट्टी (MLP Block)

class MLP(nn.Module):
    def __init__(self, embed_dim=768, mlp_ratio=4):
        super().__init__()

        self.fc1 = nn.Linear(embed_dim, embed_dim * mlp_ratio)
        self.act = nn.GELU()
        self.fc2 = nn.Linear(embed_dim * mlp_ratio, embed_dim)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.fc2(x)
        return x

Expansion → Compression
ज्ञान का निचोड़।

---

🏗 STEP 6: एक Transformer Layer

class TransformerEncoderLayer(nn.Module):
    def __init__(self, embed_dim=768, num_heads=12):
        super().__init__()

        self.norm1 = nn.LayerNorm(embed_dim)
        self.attn = MultiHeadSelfAttention(embed_dim, num_heads)

        self.norm2 = nn.LayerNorm(embed_dim)
        self.mlp = MLP(embed_dim)

    def forward(self, x):
        x = x + self.attn(self.norm1(x))   # Residual
        x = x + self.mlp(self.norm2(x))    # Residual
        return x

Residual =
सभ्यता भूलती नहीं, जोड़ती है।

---

🏛 STEP 7: पूरी Vision Transformer Model

class VisionTransformer(nn.Module):
    def __init__(
        self,
        img_size=224,
        patch_size=16,
        in_channels=3,
        embed_dim=768,
        depth=12,
        num_heads=12,
        num_classes=1000
    ):
        super().__init__()

        self.patch_embed = PatchEmbedding(
            img_size, patch_size, in_channels, embed_dim
        )

        num_patches = self.patch_embed.num_patches

        self.cls_token = CLSToken(embed_dim)
        self.pos_embed = PositionalEmbedding(num_patches, embed_dim)

        self.encoder = nn.Sequential(
            *[TransformerEncoderLayer(embed_dim, num_heads)
              for _ in range(depth)]
        )

        self.norm = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, num_classes)

    def forward(self, x):
        x = self.patch_embed(x)
        x = self.cls_token(x)
        x = self.pos_embed(x)
        x = self.encoder(x)

        cls_output = x[:, 0]        # Only CLS token
        cls_output = self.norm(cls_output)
        logits = self.head(cls_output)

        return logits

यह पूरी सभ्यता है।

---

🎓 STEP 8: अभ्यास का युग (Training)

model = VisionTransformer()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)

for images, labels in train_loader:

    outputs = model(images)
    loss = criterion(outputs, labels)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

यहाँ क्या हुआ?

• अनुमान लगाया
• गलती निकाली (loss)
• संबंध बदले (backpropagation)

यही सभ्यता का अभ्यास था।

---

🏁 STEP 9: निर्णय का काल (Inference)

model.eval()

with torch.no_grad():
    outputs = model(test_images)
    predictions = torch.argmax(outputs, dim=1)

अब संबंध स्थिर हैं।
कोई संशोधन नहीं।
सिर्फ निर्णय।

---

🧩 पूरी Pipeline Flow

Image
 ↓
Patch Split
 ↓
Linear Projection
 ↓
Add CLS Token
 ↓
Add Positional Encoding
 ↓
Transformer Layers (Attention + MLP × L)
 ↓
CLS Token Extract
 ↓
Linear Head
 ↓
Prediction

---

🧘‍♂️ अंतिम दर्शन

CNN क्या करता है?

• Local receptive field

ViT क्या करता है?

• Global relational reasoning

ViT = सभ्यता
CNN = कारीगर