CNNs process images through small sliding filters. Each filter only sees a tiny local region, and the model has to stack many layers before distant parts of an image can even talk to each other.

Vision Transformers threw that whole approach out.

ViT chops an image into patches, treats each patch like a token, and runs self-attention across the full sequence.
Every patch can attend to every other patch from the very first layer. No stacking required.

That global view from layer one is what made ViT surpass CNNs on large-scale benchmarks.

𝐖𝐡𝐚𝐭 𝐭𝐡𝐞 𝐛𝐥𝐨𝐠 𝐜𝐨𝐯𝐞𝐫𝐬:

- Introduction to Vision Transformers and comparison with CNNs
- Adapting transformers to images: patch embeddings and flattening
- Positional encodings in Vision Transformers
- Encoder-only structure for classification
- Benefits and drawbacks of ViT
- Real-world applications of Vision Transformers
- Hands-on: fine-tuning ViT for image classification

The Image below shows

Self-attention connects every pixel to every other pixel at once. Convolution only sees a small local window. That's why ViT captures things CNNs miss, like the optical illusion painting where distant patches form a hidden face.

The architecture is simple. Split image into patches, flatten them into embeddings (like words in a sentence), run them through a Transformer encoder, and the class token collects info from all patches for the final prediction. Patch in, class out.

Inside attention: each patch (query) compares itself to all other patches (keys), softmax gives attention weights, and the weighted sum of values produces a new representation aware of the full image, visualizes what the CLS token actually attends to through attention heatmaps.

The second half of the blog is hands-on code. I fine-tuned ViT-Base from google (86M params) on the Oxford-IIIT Pet dataset, 37 breeds, ~7,400 images.

𝐁𝐥𝐨𝐠 𝐋𝐢𝐧𝐤
https://vizuaranewsletter.com/p/vision-transformers?r=5b5pyd&utm_campaign=post&utm_medium=web

Explain how a hash map works internally.

A hash map stores key value pairs by applying a hash function to the key to compute an index in an underlying array. Ideally, the hash function distributes keys uniformly to minimize collisions.

When collisions occur, common strategies include chaining using linked lists or open addressing. Lookups, insertions, and deletions are O(1) on average but can degrade toward O(n) in worst case collision scenarios.

In modern implementations like Java’s HashMap, when collision chains grow beyond a threshold, they may be converted into balanced trees to maintain efficient performance.

class Smartphone:
    """A simple class to represent a smartphone."""

    # The 'Constructor' - defines attributes for every new phone
    def __init__(self, brand, model, battery_level=100):
        self.brand = brand
        self.model = model
        self.battery_level = battery_level

    # A 'Method' - defines a behavior
    def status(self):
        print(f"📱 {self.brand} {self.model} is at {self.battery_level}% battery.")

    def use_app(self, app_name, battery_drain):
        self.battery_level -= battery_drain
        print(f"Using {app_name}... drained {battery_drain}%.")

# --- Creating Instances (Objects) ---

# Phone 1
my_phone = Smartphone("Apple", "iPhone 15")
my_phone.use_app("Instagram", 15)
my_phone.status()

# Phone 2 (a separate object with its own data)
work_phone = Smartphone("Samsung", "Galaxy S23", battery_level=50)
work_phone.status()

from collections import Counter

# 1. Create a Counter from a list
fruit_basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'apple']
counts = Counter(fruit_basket)
print(f"Initial Counts: {counts}") 
# Output: Counter({'apple': 3, 'orange': 2, 'pear': 1})

# 2. Update with new data
counts.update(['banana', 'apple'])
print(f"After Update: {counts['apple']} apples") # Output: 4

# 3. Find the most common elements
# Returns a list of (element, count) tuples
print(f"Top 2 fruits: {counts.most_common(2)}")

# 4. Multiset Operations
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)

print(f"Combined (Addition): {c1 + c2}")   # Counts: a:4, b:3
print(f"Intersection (Min): {c1 & c2}")    # Counts: a:1, b:1 (lowest of both)
print(f"Union (Max): {c1 | c2}")           # Counts: a:3, b:2 (highest of both)