Tiny Recursive Model

Neural Networks untuk Struktur Tree

🌳 Apa itu Recursive Model?

Recursive Model adalah jenis neural network yang dirancang khusus untuk memproses data dengan struktur hierarkis atau tree.

Kenapa Perlu Recursive Model?

  • ✅ Bahasa alami memiliki struktur tree (parse trees)
  • ✅ Banyak data real-world berbentuk hierarki
  • ✅ Bisa menangkap komposisi makna
  • ✅ Berbagi parameter di semua node (efficient)

📖 Contoh Sederhana

Bayangkan kalimat: "not very good"

NEG not POS very good

Model memproses dari leaves (kata) ke root, mengkombinasikan makna di setiap level

🎯 Apa yang Akan Dipelajari?

🔄

Rekursi

Konsep recursion & tree traversal

🧠

Model

Arsitektur Tiny Recursive Model

⚡

Forward Pass

Bagaimana data mengalir dalam tree

📈

Training

Backpropagation through structure

Konsep Rekursi

Memahami recursion dan tree structures

🔄 Apa itu Rekursi?

Rekursi adalah teknik di mana fungsi memanggil dirinya sendiri untuk menyelesaikan masalah yang lebih kecil.

Contoh: Faktorial

def factorial(n):
    # Base case
    if n == 0 or n == 1:
        return 1
    
    # Recursive case
    return n * factorial(n - 1)

# factorial(4) = 4 * factorial(3)
#              = 4 * 3 * factorial(2)
#              = 4 * 3 * 2 * factorial(1)
#              = 4 * 3 * 2 * 1 = 24

🌲 Tree Structures

Tree adalah struktur data hierarkis dengan nodes dan edges:

Root

Node paling atas (tidak punya parent)

Leaf

Node yang tidak punya children

Internal Node

Node yang punya children

📊 Tree Traversal

Ada beberapa cara traverse tree:

Pre-order

Root → Left → Right

[Root, L1, L2, R1, R2]

Post-order ⭐

Left → Right → Root

[L1, L2, R1, R2, Root]

Digunakan di Recursive Model!

In-order

Left → Root → Right

[L1, Root, L2, R1, R2]

Recursive Neural Networks

Neural networks yang memproses tree structures

🧠 Dari Recursion ke Neural Networks

Bagaimana jika kita terapkan neural network pada tree structure?

Analogi:

Bayangkan setiap node dalam tree adalah sebuah mini neural network yang:

  • Menerima input dari children-nya
  • Memproses dengan weights & activation
  • Menghasilkan output untuk parent-nya

🏗️ Ide Dasar

Recursive NN memproses tree dari bottom-up (leaves → root):

1

Leaves (Input)

Kata-kata diubah jadi vectors

→
2

Internal Nodes

Combine children dengan NN

→
3

Root (Output)

Representasi seluruh tree

🔑 Key Insight: Parameter Sharing

Semua internal nodes menggunakan weights yang sama:

Shared Parameters:

W (Weight matrix)
b (Bias vector)

Keuntungan:

  • ✅ Lebih efisien (parameter sedikit)
  • ✅ Generalisasi lebih baik
  • ✅ Bisa handle tree dengan size berbeda

Tiny Recursive Model

Arsitektur model sederhana

🏛 Arsitektur Sederhana

Tiny Recursive Model menggunakan satu layer untuk combine children:

Formula Komputasi Node:

hparent = tanh(W · [hleft; hright] + b)

Dimana [;] adalah concatenation

🧮 Komponen Model

Input Layer

Word embeddings untuk leaves

hleaf = E[word]

Composition Function

Combine 2 children

f(h₁, h₂) = tanh(W[h₁;h₂] + b)

Output Layer

Classification dari root

y = softmax(U·hroot)

📐 Dimensi

Contoh untuk sentiment analysis (positive/negative):

Component Dimension Contoh
Embedding (d) 50 Setiap kata → vector 50-dim
Hidden (h) 50 Node representation 50-dim
W matrix 50 × 100 Transform [h₁;h₂] (100-dim) → 50-dim
Output classes 2 Positive / Negative

🎨 Visualisasi Arsitektur

Forward Pass

Bagaimana data mengalir dari leaves ke root

⚡ Proses Forward Pass

Data mengalir bottom-up menggunakan post-order traversal:

1

Leaf Nodes

Lookup word embeddings

2

Internal Nodes

Compute h = f(h_left, h_right)

3

Root Node

Final classification

🎬 Animasi Forward Pass

Lihat bagaimana representasi dihitung step-by-step:

📊 Contoh Perhitungan

Kalimat: "very good"

Step 1: Leaf Embeddings

h_very = E["very"] = [0.2, 0.5, -0.3, ...]
h_good = E["good"] = [0.8, -0.1, 0.4, ...]

Step 2: Internal Node

concat = [h_very; h_good] = [0.2, 0.5, ..., 0.8, -0.1, ...]
h_parent = tanh(W · concat + b)
h_parent = [0.6, 0.3, -0.2, ...]

Step 3: Classification

y = softmax(U · h_parent)
y = [0.85, 0.15] → "Positive" dengan 85% confidence

Training Process

Backpropagation Through Structure

📈 Bagaimana Training Bekerja?

Training menggunakan Backpropagation Through Structure (BPTS):

Forward Pass

Compute representations bottom-up

↓

Loss Calculation

Compare prediction vs label

↓

Backward Pass

Gradient flows top-down

↓

Parameter Update

W, b, E updated dengan gradient

🔙 Backpropagation Animation

Lihat bagaimana gradient mengalir dari root ke leaves:

⚙️ Training Loop

for epoch in range(num_epochs):
    total_loss = 0
    
    for tree, label in training_data:
        # Forward pass
        h_root = forward_pass(tree)
        prediction = softmax(U @ h_root)
        
        # Compute loss
        loss = cross_entropy(prediction, label)
        total_loss += loss
        
        # Backward pass
        gradients = backprop(tree, loss)
        
        # Update parameters
        W -= learning_rate * gradients['W']
        b -= learning_rate * gradients['b']
        E -= learning_rate * gradients['E']
    
    print(f"Epoch {epoch}: Loss = {total_loss}")

📊 Training Progress Visualization

Implementasi & Contoh

Dari konsep ke code

💻 Implementasi PyTorch

Tiny Recursive Model Class:

import torch
import torch.nn as nn

class TinyRecursiveModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
        super().__init__()
        
        # Word embeddings
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        
        # Composition function
        self.W = nn.Linear(2 * hidden_dim, hidden_dim)
        
        # Output classifier
        self.classifier = nn.Linear(hidden_dim, num_classes)
        
    def forward_node(self, node):
        """Recursive forward pass"""
        if node.is_leaf():
            # Leaf: return word embedding
            return self.embedding(node.word_id)
        else:
            # Internal: combine children
            h_left = self.forward_node(node.left)
            h_right = self.forward_node(node.right)
            
            # Concatenate and transform
            h_concat = torch.cat([h_left, h_right], dim=0)
            h_parent = torch.tanh(self.W(h_concat))
            
            return h_parent
    
    def forward(self, tree):
        """Process entire tree"""
        h_root = self.forward_node(tree.root)
        logits = self.classifier(h_root)
        return logits

🌳 Use Cases

Sentiment Analysis

Klasifikasi sentimen dari parse tree kalimat

"not very good" → Negative

Semantic Composition

Memahami makna komposisional

"red car" vs "car that is red"

Question Answering

Memproses struktur pertanyaan

Parse tree untuk complex questions

Image Segmentation

Hierarchical scene parsing

Object decomposition trees

🎯 Interactive Demo

Build tree Anda sendiri dan lihat hasilnya:

Build Your Tree:

🎉 Selamat!

Anda telah menyelesaikan tutorial Tiny Recursive Model!

Yang Telah Dipelajari:

  • ✅ Konsep recursion dan tree structures
  • ✅ Recursive Neural Networks
  • ✅ Tiny Recursive Model architecture
  • ✅ Forward pass computation
  • ✅ Backpropagation through structure
  • ✅ Implementasi PyTorch

Belajar Lebih Lanjut:

📚 Paper: "Recursive Deep Models for Semantic Compositionality"

🔬 Advanced: TreeLSTM, Recursive Autoencoder

💻 Practice: Implement on Stanford Sentiment Treebank