Update README.md

README.md

@@ -15,165 +15,90 @@ metrics:
 
 # ai_code_detect
 
-### Architecture
-- **Semantic Engine:** `Salesforce/codet5-base`
-- **Statistical Extraction:** `microsoft/codebert-base-mlm` (Calculates Entropy and Log-Rank across 256 tokens)
-- **Fusion Network:** 1D CNN for temporal feature extraction + Dense Feed-Forward Classifier
+Binary classifier: human-written vs. AI-generated code. Trained on 500k samples (Python, Java, C++). Macro F1: **0.9813**.
 
-### Performance Metrics
-Trained on a polyglot dataset (Python, Java, C++) to prevent single-language overfitting.
-- **Training Validation F1:** 0.9861
-- **Unseen SemEval-2026 Audit (F1):** 0.9921
-- **Overall Accuracy:** 99.20%
+---
 
-### Requires:
-transformers==4.35.2
+## Architecture
 
-### How to use
-To use this model in your own application, download the weights directly from this hub and load them into the custom `TemporalFusionClassifier` architecture.
+Two input streams fused into a single MLP classifier.
 
-```python
-from huggingface_hub import hf_hub_download
-import torch
+**Stream 1 — Probabilistic**
+
+Code is passed through `Salesforce/codegen-350M-mono`. Per-token surprisal signals are extracted across a 256-token window:
+
+| # | Feature | Description |
+|---|---------|-------------|
+| 0 | `log_prob` | Log-probability of the actual token |
+| 1 | `log_rank` | Log-rank within the distribution |
+| 2 | `entropy` | Shannon entropy of the token distribution |
+| 3 | `varentropy` | Variance of entropy |
+| 4 | `top10_mass` | Probability mass in top-10 tokens |
+| 5 | `gap_1_2` | Log-prob gap between rank-1 and rank-2 |
+| 6 | `surprisal_z` | Per-token surprisal z-score |
+| 7 | `entropy_delta` | Entropy change from previous position |
+| 8 | `cum_rank` | Cumulative mean log-rank |
+| 9 | `is_special` | Special token flag |
+| 10 | `r10_flag` | Rank ≤ 10 |
+| 11 | `r100_flag` | 10 < rank ≤ 100 |
+
+These 12 per-token features aggregate into 32 sequence-level statistics (moments, autocorrelations, burstiness, etc.) passed downstream.
+
+**Stream 2 — Semantic**
+
+`Salesforce/codet5-base` mean-pools hidden states into a 768-dim embedding capturing style, structure, naming, and comment density.
+
+**Classifier**
+
+Token (256-dim) + sequence (64-dim) + semantic (768-dim) representations are concatenated → 1088-dim → 3-layer MLP with LayerNorm, GELU, dropout → sigmoid.
+
+---
 
-weights_path = hf_hub_download(repo_id="santh-cpu/ai_code_detect", filename="pytorch_model.bin")
+## Performance
 
-model = TemporalFusionClassifier(base_model)
-model.load_state_dict(torch.load(weights_path))
-model.eval()
-```
+Evaluated on 3,000 balanced validation samples (1,000/language):
+
+| Metric | Score |
+|--------|-------|
+| Macro F1 | **0.9813** |
+| Accuracy | **98.13%** |
+| Threshold | 0.475 |
+
+| Language | Accuracy | Human p̄ | AI p̄ | Gap |
+|----------|----------|---------|-------|-----|
+| Python | 99.50% | 0.001 | 0.992 | 0.991 |
+| Java | 98.00% | 0.043 | 0.968 | 0.926 |
+| C++ | 96.90% | 0.063 | 0.966 | 0.903 |
+
+---
+
+## Training
+
+| Setting | Value |
+|---------|-------|
+| Optimizer | AdamW (encoder lr 8e-6, head lr 3e-5) |
+| Scheduler | OneCycleLR + cosine annealing |
+| Loss | BCEWithLogitsLoss |
+| Regularization | EMA (decay=0.998), dropout, LayerNorm |
+| Precision | fp16 via HuggingFace Accelerate |
+| Hardware | 2× GPU |
+| Epochs | 4 (500k samples) |
+
+
+ from SemEval-2026 Task 13 
+---
+
+## Usage
 
-### Example
 ```python
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from transformers import T5EncoderModel, AutoTokenizer, AutoModelForMaskedLM
+import os
+import sys
 from huggingface_hub import hf_hub_download
 
-class TemporalFusionClassifier(nn.Module):
-    def __init__(self, base, metric_dim=7):
-        super().__init__()
-        self.base = base
-        h = base.config.hidden_size 
-        
-        self.metric_cnn = nn.Sequential(
-            nn.Conv1d(metric_dim, 32, 3, padding=1),
-            nn.BatchNorm1d(32),
-            nn.ReLU(),
-            nn.MaxPool1d(2),
-            nn.Conv1d(32, 64, 3, padding=1),
-            nn.BatchNorm1d(64),
-            nn.ReLU(),
-            nn.AdaptiveAvgPool1d(1) 
-        )
-        
-        self.classifier = nn.Sequential(
-            nn.Linear(h + 64, 1024),
-            nn.ReLU(),
-            nn.Dropout(0.1),
-            nn.Linear(1024, 1)
-        )
-
-    def forward(self, input_ids, attention_mask, metric_vector):
-        out = self.base(input_ids=input_ids, attention_mask=attention_mask)
-        hidden = out.last_hidden_state            
-        mask = attention_mask.unsqueeze(-1).float()          
-        pooled = (hidden * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-4)
-        
-        cnn_features = self.metric_cnn(metric_vector.transpose(1, 2)).squeeze(-1) 
-        return self.classifier(torch.cat([pooled, cnn_features], dim=1)) 
-
-class AICodeDetector:
-    def __init__(self, repo_id="santh-cpu/ai_code_detect"):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.max_len = 256
-        
-        self.cb_tokenizer = AutoTokenizer.from_pretrained("microsoft/codebert-base-mlm")
-        self.cb_model = AutoModelForMaskedLM.from_pretrained("microsoft/codebert-base-mlm").to(self.device).eval()
-
-        self.t5_tokenizer = AutoTokenizer.from_pretrained("Salesforce/codet5-base")
-        base_t5 = T5EncoderModel.from_pretrained("Salesforce/codet5-base")
-        
-        weights_path = hf_hub_download(repo_id=repo_id, filename="pytorch_model.bin")
-        self.detector = TemporalFusionClassifier(base_t5).to(self.device)
-        self.detector.load_state_dict(torch.load(weights_path, map_location=self.device))
-        self.detector.eval()
-
-    def analyze(self, code_snippet):
-        with torch.no_grad():
-            cb_in = self.cb_tokenizer(code_snippet, return_tensors="pt", padding="max_length", truncation=True, max_length=self.max_len).to(self.device)
-            logits = self.cb_model(**cb_in).logits
-                
-            seq_len = cb_in["attention_mask"][0].sum().item()
-            metrics = torch.zeros((1, self.max_len, 7), device=self.device)
-            
-            if seq_len > 1:
-                seq_logits = logits[0:1, :seq_len-1, :]
-                seq_labels = cb_in["input_ids"][0:1, 1:seq_len]
-                probs = F.softmax(seq_logits, dim=-1)
-                
-                entropy = -torch.sum(probs * torch.log(probs + 1e-9), dim=-1)
-                ranks = (torch.argsort(seq_logits, dim=-1, descending=True) == seq_labels.unsqueeze(-1)).nonzero(as_tuple=True)[2].view(1, -1) + 1
-                
-                token_metrics = torch.stack([
-                    torch.log(probs.gather(2, seq_labels.unsqueeze(-1)).squeeze(-1) + 1e-9), 
-                    torch.log(ranks.float()), 
-                    entropy,
-                    (ranks <= 10).float(),
-                    ((ranks > 10) & (ranks <= 100)).float(),
-                    ((ranks > 100) & (ranks <= 1000)).float(),
-                    (ranks > 1000).float()
-                ], dim=-1)
-                metrics[0, :token_metrics.size(1), :] = token_metrics[0]
-            
-            clean_metrics = torch.nan_to_num(metrics, nan=0.0, posinf=10.0, neginf=-100.0)
-            t5_in = self.t5_tokenizer(code_snippet, return_tensors="pt", padding="max_length", truncation=True, max_length=self.max_len).to(self.device)
-            prob = torch.sigmoid(self.detector(t5_in["input_ids"], t5_in["attention_mask"], clean_metrics)).item()
-            
-            return {"prediction": "AI Generated" if prob > 0.5 else "Human Written", "ai_probability": round(prob * 100, 2)}
-
-sample = """
-#include <bits/stdc++.h>
-using namespace std;
-
-int main() {
-    ios::sync_with_stdio(0);
-    cin.tie(0);
-
-    int n, k, w;
-    string s;
-    cin >> n >> k >> w >> s;
-
-    vector<vector<long long>> pre(k, vector<long long>(n));
-
-    for (int i = 0; i < k; ++i) {
-        for (int j = 0; j < n; ++j) {
-            if (j % k == i && s[j] == '0')
-                pre[i][j]++;
-
-            if (j % k != i && s[j] == '1')
-                pre[i][j]++;
-
-            if (j > 0)
-                pre[i][j] += pre[i][j - 1];
-        }
-    }
-
-    for (int i = 0; i < w; ++i) {
-        int l, r;
-        cin >> l >> r;
-        l--, r--;
-
-        int m = (l + k - 1) % k;
-
-        cout << pre[m][r] - (l > 0 ? pre[m][l - 1] : 0) << "\n";
-    }
-
-    return 0;
-}"""
-
-if __name__ == "__main__":
-    detector = AICodeDetector()
-    print("\n",detector.analyze(sample))
+REPO_ID = "santh-cpu/ai_code_detect"
+script_path = hf_hub_download(repo_id=REPO_ID, filename="model.py")
+sys.path.append(os.path.dirname(script_path))
+from model import predict
+
+print(predict("your code here"))
 ```