Finalized.

README.md

@@ -11,4 +11,190 @@ license: mit
 short_description: Convert C++ to Pseudocode using a Transformer Model.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔄 Code2Pseudo – Transformer-based C++ to Pseudocode Converter
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+[![Hugging Face](https://img.shields.io/badge/HuggingFace-Spaces-orange)](https://huggingface.co/spaces/asadsandhu/Code2Pseudo)
+[![GitHub Repo](https://img.shields.io/badge/GitHub-asadsandhu/Code2Pseudo-black?logo=github)](https://github.com/asadsandhu/Code2Pseudo)
+
+> A fully custom Transformer-based Sequence-to-Sequence model built from scratch in PyTorch to convert executable C++ code into high-level pseudocode. Trained on the [SPoC dataset](https://arxiv.org/abs/2005.04326) from Stanford.
+
+---
+
+## 🖼️ Demo
+
+Try it live on **Hugging Face Spaces**:  
+👉 https://huggingface.co/spaces/asadsandhu/Code2Pseudo
+
+![App Demo](assets/demo.png)
+
+---
+
+## 🧠 Model Architecture
+
+- Built from scratch using the **Transformer** encoder-decoder architecture (PyTorch)
+- No pre-trained libraries – 100% custom code
+- Token-level sequence generation with greedy decoding
+- Custom tokenization and vocabulary building for both C++ and pseudocode
+
+```
+
+Input:   C++ lines (line-by-line)
+Model:   Transformer (Encoder-Decoder)
+Output:  Corresponding pseudocode line
+
+```
+
+---
+
+## 📊 Dataset
+
+We trained on the **SPoC dataset**:
+
+- ✅ Cleanly aligned C++ ↔ pseudocode line pairs
+- ✅ High-quality syntactic coverage
+- ✅ Multiple test splits available
+- ✅ Custom preprocessing and token handling
+
+> 📎 Licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)
+
+---
+
+## 📁 Directory Structure
+
+```
+
+.
+├── app.py                # Gradio web app (C++ → Pseudocode)
+├── train.py              # Training script for code-to-pseudocode model
+├── model.pth             # Trained model and vocab checkpoint
+├── spoc/
+│   └── train/
+│       ├── spoc-train.tsv
+│       └── split/spoc-train-eval.tsv
+├── assets/
+│   └── demo.png          # Screenshot for README
+└── README.md             # This file
+
+````
+
+---
+
+## 🛠️ How to Run Locally
+
+### ⚙️ 1. Clone the Repo
+
+```bash
+git clone https://github.com/asadsandhu/Code2Pseudo.git
+cd Code2Pseudo
+pip install torch gradio tqdm
+````
+
+### 🚀 2. Launch the Web App
+
+Make sure `model.pth` exists (or train it first):
+
+```bash
+python app.py
+```
+
+The interface will open in your browser.
+
+---
+
+## 🧪 Training the Model
+
+To retrain the transformer model:
+
+```bash
+python train.py
+```
+
+By default:
+
+* Downloads SPoC dataset from GitHub
+* Trains for 10 epochs
+* Produces `model.pth` with weights and vocabulary
+
+---
+
+## 🔧 Key Hyperparameters
+
+| Parameter      | Value       |
+| -------------- | ----------- |
+| Model Type     | Transformer |
+| Max Length     | 128         |
+| Embedding Dim  | 256         |
+| FFN Dim        | 512         |
+| Heads          | 4           |
+| Encoder Layers | 2           |
+| Decoder Layers | 2           |
+| Batch Size     | 64          |
+| Epochs         | 10          |
+| Optimizer      | Adam        |
+| Learning Rate  | 1e-4        |
+
+---
+
+## 🧩 Example Input
+
+```cpp
+int main() {
+int n , nn , ans = 0 ;
+cin > > n ;
+for ( int i = 2 ; i < = n - 1 ; i + + ) {
+nn = n ;
+while ( nn = = 0 ) ans + = nn % i , nn / = i ;
+}
+o = gcd ( ans , n - 2 ) ;
+cout < < ans / 2 / o ( n - 2 ) / o < < endl ;
+return 0;
+}
+```
+
+### ⏩ Output Pseudocode
+
+```text
+create integers n , nn , ans with ans = 0
+read n
+for i = 2 to n - 1 inclusive
+set nn to n
+while nn is 0 , set ans to nn % 12 , set ans to nn % nn , set nn to nn / i
+set value of gcd to ans and n - 2
+print ans / 2 / ( n - 2 ) / o
+```
+
+---
+
+## 📦 Deployment
+
+Live demo hosted on:
+
+* **Hugging Face Spaces**: [Code2Pseudo](https://huggingface.co/spaces/asadsandhu/Code2Pseudo)
+* **GitHub**: [github.com/asadsandhu/Code2Pseudo](https://github.com/asadsandhu/Code2Pseudo)
+
+---
+
+## 🙌 Acknowledgements
+
+* 📘 **SPoC Dataset** by Stanford University
+  Kulal, S., Pasupat, P., & Liang, P. (2020). [SPoC: Search-based Pseudocode to Code](https://arxiv.org/abs/2005.04326)
+
+* 🧠 Transformer Paper: ["Attention is All You Need"](https://arxiv.org/abs/1706.03762)
+
+---
+
+## 🧑‍💻 Author
+
+**Asad Ali**
+[GitHub: asadsandhu](https://github.com/asadsandhu)
+[Hugging Face: asadsandhu](https://huggingface.co/asadsandhu)
+[LinkedIn: asadxali](https://www.linkedin.com/in/asadxali)
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License.
+Use, remix, and distribute freely with attribution.

app.py

@@ -0,0 +1,215 @@
+# app.py (for C++ to Pseudocode task)
+import gradio as gr
+import torch
+import os
+import math
+import torch.nn as nn
+import re
+import sys
+import asyncio
+
+if sys.platform.startswith('win'):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+MAX_LEN = 128
+EMBED_DIM = 256
+NHEAD = 4
+NUM_ENCODER_LAYERS = 2
+NUM_DECODER_LAYERS = 2
+FF_DIM = 512
+
+PAD_TOKEN = "<pad>"
+SOS_TOKEN = "<sos>"
+EOS_TOKEN = "<eos>"
+UNK_TOKEN = "<unk>"
+
+def tokenize_line(text):
+    return re.findall(r"[A-Za-z0-9]+|[^\sA-Za-z0-9]", text)
+
+def numericalize(text, stoi):
+    tokens = tokenize_line(text)
+    return [stoi.get(tok, stoi[UNK_TOKEN]) for tok in tokens]
+
+def pad_sequence(seq, max_len, pad_id):
+    seq = seq[:max_len-1]
+    seq = seq + [tgt_stoi[EOS_TOKEN]]
+    if len(seq) < max_len:
+        seq += [pad_id] * (max_len - len(seq))
+    return seq
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, max_len=5000):
+        super().__init__()
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0)
+        self.register_buffer("pe", pe)
+    def forward(self, x):
+        return x + self.pe[:, :x.size(1), :]
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self, d_model, n_heads):
+        super().__init__()
+        assert d_model % n_heads == 0
+        self.head_dim = d_model // n_heads
+        self.n_heads = n_heads
+        self.query_linear = nn.Linear(d_model, d_model)
+        self.key_linear = nn.Linear(d_model, d_model)
+        self.value_linear = nn.Linear(d_model, d_model)
+        self.out_linear = nn.Linear(d_model, d_model)
+    def forward(self, query, key, value, mask=None):
+        B, Q_len, _ = query.size()
+        Q = self.query_linear(query).view(B, Q_len, self.n_heads, self.head_dim).transpose(1, 2)
+        K = self.key_linear(key).view(B, key.size(1), self.n_heads, self.head_dim).transpose(1, 2)
+        V = self.value_linear(value).view(B, value.size(1), self.n_heads, self.head_dim).transpose(1, 2)
+        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)
+        if mask is not None:
+            scores = scores.masked_fill(mask == 0, float('-inf'))
+        attn = torch.softmax(scores, dim=-1)
+        context = torch.matmul(attn, V).transpose(1, 2).contiguous().view(B, Q_len, -1)
+        return self.out_linear(context)
+
+class FeedForward(nn.Module):
+    def __init__(self, d_model, dim_feedforward):
+        super().__init__()
+        self.fc1 = nn.Linear(d_model, dim_feedforward)
+        self.fc2 = nn.Linear(dim_feedforward, d_model)
+        self.relu = nn.ReLU()
+    def forward(self, x):
+        return self.fc2(self.relu(self.fc1(x)))
+
+class EncoderLayer(nn.Module):
+    def __init__(self, d_model, n_heads, dim_feedforward):
+        super().__init__()
+        self.self_attn = MultiHeadAttention(d_model, n_heads)
+        self.ff = FeedForward(d_model, dim_feedforward)
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(0.1)
+    def forward(self, src, src_mask=None):
+        src = self.norm1(src + self.dropout(self.self_attn(src, src, src, mask=src_mask)))
+        src = self.norm2(src + self.dropout(self.ff(src)))
+        return src
+
+class DecoderLayer(nn.Module):
+    def __init__(self, d_model, n_heads, dim_feedforward):
+        super().__init__()
+        self.self_attn = MultiHeadAttention(d_model, n_heads)
+        self.cross_attn = MultiHeadAttention(d_model, n_heads)
+        self.ff = FeedForward(d_model, dim_feedforward)
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(0.1)
+    def forward(self, tgt, memory, tgt_mask=None, memory_mask=None):
+        tgt = self.norm1(tgt + self.dropout(self.self_attn(tgt, tgt, tgt, mask=tgt_mask)))
+        tgt = self.norm2(tgt + self.dropout(self.cross_attn(tgt, memory, memory, mask=memory_mask)))
+        tgt = self.norm3(tgt + self.dropout(self.ff(tgt)))
+        return tgt
+
+class Encoder(nn.Module):
+    def __init__(self, vocab_size, d_model, n_heads, num_layers, dim_feedforward):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, d_model)
+        self.pos_encoding = PositionalEncoding(d_model)
+        self.layers = nn.ModuleList([EncoderLayer(d_model, n_heads, dim_feedforward) for _ in range(num_layers)])
+    def forward(self, src, src_mask=None):
+        x = self.embedding(src)
+        x = self.pos_encoding(x)
+        for layer in self.layers:
+            x = layer(x, src_mask)
+        return x
+
+class Decoder(nn.Module):
+    def __init__(self, vocab_size, d_model, n_heads, num_layers, dim_feedforward):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, d_model)
+        self.pos_encoding = PositionalEncoding(d_model)
+        self.layers = nn.ModuleList([DecoderLayer(d_model, n_heads, dim_feedforward) for _ in range(num_layers)])
+        self.fc_out = nn.Linear(d_model, vocab_size)
+    def forward(self, tgt, memory, tgt_mask=None, memory_mask=None):
+        x = self.embedding(tgt)
+        x = self.pos_encoding(x)
+        for layer in self.layers:
+            x = layer(x, memory, tgt_mask, memory_mask)
+        return self.fc_out(x)
+
+class TransformerSeq2Seq(nn.Module):
+    def __init__(self, src_vocab_size, tgt_vocab_size, d_model, n_heads,
+                 num_encoder_layers, num_decoder_layers, dim_feedforward):
+        super().__init__()
+        self.encoder = Encoder(src_vocab_size, d_model, n_heads, num_encoder_layers, dim_feedforward)
+        self.decoder = Decoder(tgt_vocab_size, d_model, n_heads, num_decoder_layers, dim_feedforward)
+    def forward(self, src, tgt, src_mask=None, tgt_mask=None):
+        memory = self.encoder(src, src_mask)
+        return self.decoder(tgt, memory, tgt_mask)
+
+def generate_subsequent_mask(size):
+    mask = torch.triu(torch.ones(size, size), diagonal=1).bool()
+    return ~mask
+
+def greedy_decode(model, src, src_stoi, tgt_stoi, tgt_itos, max_len=MAX_LEN):
+    model.eval()
+    src = torch.tensor(src, dtype=torch.long, device=DEVICE).unsqueeze(0)
+    memory = model.encoder(src)
+    ys = torch.tensor([tgt_stoi[SOS_TOKEN]], dtype=torch.long, device=DEVICE).unsqueeze(0)
+    for _ in range(max_len-1):
+        tgt_mask = generate_subsequent_mask(ys.size(1)).to(DEVICE)
+        out = model.decoder(ys, memory, tgt_mask)
+        next_token = torch.argmax(out[:, -1, :], dim=-1).item()
+        ys = torch.cat([ys, torch.tensor([[next_token]], device=DEVICE)], dim=1)
+        if next_token == tgt_stoi[EOS_TOKEN]:
+            break
+    out_tokens = ys.squeeze(0).tolist()[1:]
+    if tgt_stoi[EOS_TOKEN] in out_tokens:
+        out_tokens = out_tokens[:out_tokens.index(tgt_stoi[EOS_TOKEN])]
+    return " ".join(tgt_itos[t] for t in out_tokens)
+
+# Load model checkpoint
+checkpoint = torch.load("model.pth", map_location=DEVICE)
+src_stoi = checkpoint['src_stoi']
+src_itos = checkpoint['src_itos']
+tgt_stoi = checkpoint['tgt_stoi']
+tgt_itos = checkpoint['tgt_itos']
+
+model = TransformerSeq2Seq(
+    src_vocab_size=len(src_stoi),
+    tgt_vocab_size=len(tgt_stoi),
+    d_model=EMBED_DIM,
+    n_heads=NHEAD,
+    num_encoder_layers=NUM_ENCODER_LAYERS,
+    num_decoder_layers=NUM_DECODER_LAYERS,
+    dim_feedforward=FF_DIM
+).to(DEVICE)
+model.load_state_dict(checkpoint['model_state_dict'])
+model.eval()
+
+def convert_cpp_to_pseudocode(code_text):
+    lines = code_text.strip().split('\n')
+    outputs = []
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line or line in ["int main() {", "}", "return 0;"]:
+            continue
+        try:
+            src_ids = numericalize(line, src_stoi)
+            src_ids = pad_sequence(src_ids, MAX_LEN, src_stoi[PAD_TOKEN])
+            out_line = greedy_decode(model, src_ids, src_stoi, tgt_stoi, tgt_itos)
+            outputs.append(out_line)
+        except Exception as e:
+            outputs.append(f"// Error in line {i+1}: {e}")
+    return "\n".join(outputs)
+
+iface = gr.Interface(
+    fn=convert_cpp_to_pseudocode,
+    inputs=gr.Textbox(label="Enter C++ Code", lines=10),
+    outputs=gr.Textbox(label="Generated Pseudocode"),
+    title="C++ to Pseudocode Converter (Transformer from Scratch)"
+)
+
+if __name__ == "__main__":
+    iface.launch()

model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51b116f0bd343a4ad7738033120b923b91c4c52c78affec025490be5adaf974b
+size 42692428

requirements.txt

@@ -0,0 +1,2 @@
+streamlit==1.35.0
+torch==2.2.2