Raw Text: "This film was breathtaking..."
   │
[1. Regex Tokenization & Lowercase] ──► ['this', 'film', 'was', 'breathtaking']
   │
[2. Vocabulary Index Lookup]       ──► [42, 319, 14, 8942]
   │
[3. nn.Embedding Lookup Table]     ──► Tensor of Shape [Batch, Seq_Len, Embedding_Dim]
   │
[4. Bidirectional LSTM Stack]      ──► Forward & Backward Hidden Context Vectors
   │
[5. Classification Head]           ──► Raw Scalar Logit ➔ Probability

import re
from collections import Counter
import torch
from torch.utils.data import Dataset, DataLoader

# Sample ingestion
raw_reviews = [
    ("This movie was absolutely incredible and stunning", 1),
    ("Terrible waste of time. Poor acting and dreadful plot.", 0),
    ("A masterpiece of modern cinematic storytelling.", 1),
    ("Boring, predictable, and completely uninspired.", 0),
]

def tokenize(text: str):
    text = re.sub(r'<[^>]+>', ' ', text.lower())  # Remove HTML tags
    return re.findall(r'\b\w+\b', text)

# Build Vocabulary
word_counts = Counter()
for text, _ in raw_reviews:
    word_counts.update(tokenize(text))

# Assign token indices (<PAD>=0, <UNK>=1)
vocab = {"<PAD>": 0, "<UNK>": 1}
for word, count in word_counts.items():
    if count >= 1:
        vocab[word] = len(vocab)

VOCAB_SIZE = len(vocab)
MAX_LEN = 32

def encode_text(text: str, max_len: int = MAX_LEN):
    tokens = tokenize(text)
    indices = [vocab.get(t, vocab["<UNK>"]) for t in tokens]
    if len(indices) < max_len:
        indices += [vocab["<PAD>"]] * (max_len - len(indices))
    else:
        indices = indices[:max_len]
    return indices

class IMDbDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        text, label = self.data[idx]
        seq = encode_text(text)
        return torch.tensor(seq, dtype=torch.long), torch.tensor(label, dtype=torch.float32)

dataset = IMDbDataset(raw_reviews)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

import torch.nn as nn

class SentimentBiLSTM(nn.Module):
    def __init__(self, vocab_size: int, embed_dim: int = 64, hidden_dim: int = 64):
        super(SentimentBiLSTM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        self.lstm = nn.LSTM(
            embed_dim,
            hidden_dim,
            num_layers=2,
            batch_first=True,
            bidirectional=True,
            dropout=0.25
        )
        # Bidirectional LSTM concatenates forward and backward hidden states (hidden_dim * 2)
        self.fc = nn.Sequential(
            nn.Linear(hidden_dim * 2, 32),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(32, 1)
        )

    def forward(self, text_seq: torch.Tensor) -> torch.Tensor:
        # text_seq: [Batch, Seq_Len]
        embedded = self.embedding(text_seq)  # [Batch, Seq_Len, Embed_Dim]
        
        # LSTM returns: output, (hidden, cell)
        lstm_out, (hidden, cell) = self.lstm(embedded)
        
        # Concatenate final forward and backward hidden states
        # hidden shape: [num_layers * 2, Batch, Hidden_Dim]
        forward_hidden = hidden[-2, :, :]
        backward_hidden = hidden[-1, :, :]
        cat_hidden = torch.cat((forward_hidden, backward_hidden), dim=1)  # [Batch, Hidden_Dim * 2]
        
        logits = self.fc(cat_hidden)
        return logits

model = SentimentBiLSTM(vocab_size=VOCAB_SIZE, embed_dim=64, hidden_dim=64)

criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-4)

for epoch in range(1, 11):
    model.train()
    running_loss = 0.0
    for bx, by in loader:
        optimizer.zero_grad()
        logits = model(bx).squeeze(1)
        loss = criterion(logits, by)
        loss.backward()
        
        # Prevent exploding recurrent gradients
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        running_loss += loss.item() * bx.size(0)

model.eval()

def predict_sentiment(review_text: str) -> dict:
    seq = torch.tensor([encode_text(review_text)], dtype=torch.long)
    with torch.no_grad():
        logit = model(seq)
        prob = torch.sigmoid(logit).item()
        
    return {
        "review": review_text,
        "sentiment": "POSITIVE" if prob >= 0.50 else "NEGATIVE",
        "confidence": prob if prob >= 0.50 else (1.0 - prob)
    }

print(predict_sentiment("An incredible cinematic triumph with brilliant direction!"))