Upload automata_core.py with huggingface_hub

automata_core.py

@@ -0,0 +1,289 @@
+import graphviz
+import re
+import torch
+import os
+import pandas as pd
+import pickle
+import torch.nn as nn
+from torchvision import models, transforms
+from PIL import Image
+
+# CONFIG
+VISION_MODEL_PATH = "automata_model.pth"
+LOGIC_MODEL_PATH = "logic_model.pth"
+VISION_CLASSES = ['ADVANCED_TOC', 'DFA', 'MINIMAL_DFA', 'NFA', 'PDA', 'TM', 'TRANSDUCER']
+
+# --- NEURAL NETWORK DEFINITION (Must match training) ---
+class LogicBrain(nn.Module):
+    def __init__(self, vocab_size, num_intents):
+        super(LogicBrain, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, 128) # EMBED_DIM
+        self.lstm = nn.LSTM(128, 256, num_layers=2, batch_first=True, bidirectional=True) # HIDDEN_DIM
+        self.fc = nn.Linear(256 * 2, num_intents)
+        
+    def forward(self, x):
+        emb = self.embedding(x)
+        out, _ = self.lstm(emb)
+        out, _ = torch.max(out, dim=1) 
+        return self.fc(out)
+
+class Vocabulary:
+    def __init__(self): self.word2idx = {}
+    def encode(self, text, max_len=20):
+        tokens = re.findall(r"\w+", text.lower())
+        vec = [self.word2idx.get(t, 1) for t in tokens[:max_len]]
+        vec += [0] * (max_len - len(vec))
+        return vec
+
+class AutomataCore:
+    def __init__(self):
+        self.device = torch.device("cpu")
+        
+        # 1. Load Vision Model (The Eye)
+        self.vision_model = self._load_vision()
+        
+        # 2. Load Logic Brain (The NLP Mind)
+        self.vocab = None
+        self.intents = None
+        self.logic_model = self._load_brain()
+
+        # 3. Logic Map
+        self.func_map = {
+            "DFA_SUBSTRING": self._dfa_substring,
+            "DFA_ENDS_WITH": self._dfa_ends_with,
+            "DFA_STARTS_WITH": self._dfa_starts_with,
+            "DFA_LENGTH": self._dfa_length,
+            "DFA_CONSECUTIVE": self._dfa_consecutive,
+            "TM_PALINDROME": self._tm_palindrome,
+            "TM_ADDER": self._tm_adder,
+            "PDA_ANBN": self._pda_anbn,
+            "MOORE_MODULO": self._moore_modulo
+        }
+
+    def _load_vision(self):
+        if not os.path.exists(VISION_MODEL_PATH): return None
+        try:
+            m = models.resnet18(weights=None)
+            m.fc = torch.nn.Linear(m.fc.in_features, len(VISION_CLASSES))
+            m.load_state_dict(torch.load(VISION_MODEL_PATH, map_location=self.device))
+            m.eval()
+            return m
+        except: return None
+
+    def _load_brain(self):
+        if not os.path.exists(LOGIC_MODEL_PATH): 
+            print("⚠️ Brain not found. Using Regex fallback.")
+            return None
+        try:
+            with open("vocab.pkl", "rb") as f: self.vocab = pickle.load(f)
+            with open("intents.pkl", "rb") as f: self.intents = pickle.load(f)
+            
+            # Recreate model structure
+            model = LogicBrain(len(self.vocab.word2idx), len(self.intents))
+            model.load_state_dict(torch.load(LOGIC_MODEL_PATH, map_location=self.device))
+            model.eval()
+            print("🧠 Neural Brain Loaded (1.5M Parameter Version)")
+            return model
+        except Exception as e:
+            print(f"⚠️ Error loading brain: {e}")
+            return None
+
+    def _infer_alphabet(self, text):
+        if not text: return ['0', '1']
+        chars = set(text)
+        if chars.issubset({'0', '1'}): return ['0', '1']
+        return sorted(list(chars))
+
+    # --- MAIN GENERATION FUNCTION ---
+    def generate_system(self, prompt):
+        prompt = prompt.lower()
+        intent = "UNKNOWN"
+        confidence = 0.0
+
+        # A. NEURAL INFERENCE (Primary)
+        if self.logic_model:
+            vec = torch.tensor([self.vocab.encode(prompt)])
+            with torch.no_grad():
+                logits = self.logic_model(vec)
+                probs = torch.nn.functional.softmax(logits, dim=1)
+                conf, idx = torch.max(probs, 1)
+                intent = self.intents[idx.item()]
+                confidence = conf.item()
+
+        # B. REGEX FALLBACK (Secondary)
+        if intent == "UNKNOWN" or confidence < 0.6:
+            # Fallback patterns if AI is unsure
+            if "substring" in prompt: intent = "DFA_SUBSTRING"
+            elif "end" in prompt: intent = "DFA_ENDS_WITH"
+            elif "start" in prompt: intent = "DFA_STARTS_WITH"
+            elif "adder" in prompt: intent = "TM_ADDER"
+            elif "mod" in prompt: intent = "MOORE_MODULO"
+        
+        # C. PARAMETER EXTRACTION
+        # (Neural nets are bad at copying exact strings, so we use regex for the parameter)
+        tokens = re.findall(r"[a-z0-9]+", prompt)
+        stopwords = ["dfa", "tm", "make", "generate", "machine", "the", "with", "ends", "starts", "substring", "containing", "automata", "construct", "build"]
+        candidates = [t for t in tokens if t not in stopwords]
+        param = candidates[-1] if candidates else "01"
+
+        # D. RENDER
+        dot = graphviz.Digraph(engine='dot', format='png')
+        dot.attr(rankdir='LR', bgcolor='transparent', nodesep='0.6', ranksep='0.5')
+        dot.attr('node', style='filled', fillcolor='#2B2B2B', color='#5c85d6', fontcolor='white', fontname='Arial')
+        dot.attr('edge', color='#5c85d6', fontcolor='white', fontname='Arial')
+        dot.node('start', '', shape='none', width='0')
+
+        transitions = []
+        if intent in self.func_map:
+            transitions = self.func_map[intent](dot, param)
+            logic_name = f"{intent} (AI Conf: {confidence*100:.1f}%)"
+        else:
+            transitions = self._dfa_exact(dot, param)
+            logic_name = "Exact Match (AI Unsure)"
+
+        return dot, transitions, logic_name
+
+    # --- BUILDER LOGIC (Same as before) ---
+    def _dfa_substring(self, dot, sub):
+        transitions = []
+        states = len(sub) + 1
+        dot.edge('start', 'q0')
+        alphabet = self._infer_alphabet(sub)
+        for i in range(states):
+            is_final = (i == len(sub))
+            shape = 'doublecircle' if is_final else 'circle'
+            dot.node(f'q{i}', shape=shape)
+            if is_final:
+                dot.edge(f'q{i}', f'q{i}', ",".join(alphabet))
+                for c in alphabet: transitions.append({"State":f"q{i}", "In":c, "Next":f"q{i}"})
+                continue
+            for char in alphabet:
+                pattern = sub[:i] + char
+                nxt = 0
+                for l in range(len(pattern), 0, -1):
+                    if sub.startswith(pattern[-l:]): nxt = l; break
+                dot.edge(f'q{i}', f'q{nxt}', char)
+                transitions.append({"State":f"q{i}", "In":char, "Next":f"q{nxt}"})
+        return transitions
+
+    def _dfa_ends_with(self, dot, sub):
+        transitions = []
+        states = len(sub) + 1
+        dot.edge('start', 'q0')
+        alphabet = self._infer_alphabet(sub)
+        for i in range(states):
+            shape = 'doublecircle' if i == len(sub) else 'circle'
+            dot.node(f'q{i}', shape=shape)
+            for char in alphabet:
+                curr = sub[:i] + char
+                nxt = 0
+                for l in range(min(len(curr), len(sub)), 0, -1):
+                    if sub.startswith(curr[-l:]): nxt = l; break
+                dot.edge(f'q{i}', f'q{nxt}', char)
+                transitions.append({"State":f"q{i}", "In":char, "Next":f"q{nxt}"})
+        return transitions
+
+    def _dfa_starts_with(self, dot, prefix):
+        transitions = []
+        dot.edge('start', 'q0')
+        prev = 'q0'
+        alphabet = self._infer_alphabet(prefix)
+        for i, char in enumerate(prefix):
+            curr = f'q{i+1}'
+            dot.edge(prev, curr, char)
+            transitions.append({"State":prev, "In":char, "Next":curr})
+            for oc in [c for c in alphabet if c != char]:
+                dot.edge(prev, 'dead', oc)
+                transitions.append({"State":prev, "In":oc, "Next":'dead'})
+            prev = curr
+        dot.node(prev, shape='doublecircle'); dot.edge(prev,prev, ",".join(alphabet))
+        dot.node('dead', shape='circle'); dot.edge('dead','dead', ",".join(alphabet))
+        return transitions
+
+    def _dfa_length(self, dot, param):
+        try: n = int(re.search(r'\d+', str(param)).group())
+        except: n = 3
+        transitions = []
+        dot.edge('start', 'q0')
+        for i in range(n):
+            dot.edge(f'q{i}', f'q{i+1}', '0,1')
+            transitions.append({"State":f"q{i}", "In":"0,1", "Next":f"q{i+1}"})
+        dot.node(f'q{n}', shape='doublecircle')
+        dot.edge(f'q{n}', 'trap', '0,1'); dot.edge('trap','trap','0,1')
+        return transitions
+        
+    def _dfa_consecutive(self, dot, param):
+        c = param[0] if param else "0"
+        transitions = []
+        dot.edge('start', 'q0'); dot.node('q2', shape='doublecircle')
+        other = '1' if c == '0' else '0'
+        
+        # q0
+        dot.edge('q0', 'q1', c); transitions.append({"State":'q0', "In":c, "Next":'q1'})
+        dot.edge('q0', 'q0', other); transitions.append({"State":'q0', "In":other, "Next":'q0'})
+        # q1
+        dot.edge('q1', 'q2', c); transitions.append({"State":'q1', "In":c, "Next":'q2'})
+        dot.edge('q1', 'q0', other); transitions.append({"State":'q1', "In":other, "Next":'q0'})
+        # q2
+        dot.edge('q2', 'q2', '0,1')
+        return transitions
+
+    def _dfa_exact(self, dot, s):
+        transitions = []
+        dot.edge('start', 'q0')
+        for i, c in enumerate(s):
+            dot.edge(f'q{i}', f'q{i+1}', c)
+            transitions.append({"State":f"q{i}", "In":c, "Next":f"q{i+1}"})
+        dot.node(f'q{len(s)}', shape='doublecircle')
+        return transitions
+
+    def _tm_palindrome(self, dot, _):
+        transitions = []
+        dot.edge('start', 'q0'); dot.node('accept', shape='doublecircle')
+        edges = [('q0','scan','B/B,R'), ('scan','scan','0,1/0,1,R'), ('scan','check','B/B,L'),
+                 ('check','back','0/B,L'), ('check','back','1/B,L'), ('back','match','B/B,R'),
+                 ('match','q0','0,1/B,R'), ('q0','accept','B/B,R')]
+        for u,v,l in edges: 
+            dot.edge(u,v,l); transitions.append({"State":u, "Rule":l, "Next":v})
+        return transitions
+
+    def _tm_adder(self, dot, _):
+        transitions = []
+        dot.edge('start', 'q0'); dot.node('halt', shape='doublecircle')
+        edges = [('q0','q0','0/0,R'), ('q0','q0','1/1,R'), ('q0','carry','B/B,L'),
+                 ('carry','carry','1/0,L'), ('carry','halt','0/1,R'), ('carry','halt','B/1,R')]
+        for u,v,l in edges: 
+            dot.edge(u,v,l); transitions.append({"State":u, "Rule":l, "Next":v})
+        return transitions
+
+    def _pda_anbn(self, dot, _):
+        transitions = []
+        dot.edge('start', 'q0'); dot.node('accept', shape='doublecircle')
+        edges = [('q0','q1','ε,ε->Z0'), ('q1','q1','a,ε->A'), ('q1','q2','b,A->ε'),
+                 ('q2','q2','b,A->ε'), ('q2','accept','ε,Z0->ε')]
+        for u,v,l in edges: 
+            dot.edge(u,v,l); transitions.append({"State":u, "Rule":l, "Next":v})
+        return transitions
+
+    def _moore_modulo(self, dot, param):
+        try: k = int(re.search(r'\d+', str(param)).group())
+        except: k = 3
+        transitions = []
+        dot.edge('start', 'q0')
+        for i in range(k):
+            out = 1 if i == 0 else 0
+            dot.node(f'q{i}', label=f'q{i}/{out}')
+            n0=(i*2)%k; n1=(i*2+1)%k
+            dot.edge(f'q{i}', f'q{n0}', '0'); dot.edge(f'q{i}', f'q{n1}', '1')
+            transitions.append({"State":f"q{i}", "Out":out, "In(0)":f"q{n0}", "In(1)":f"q{n1}"})
+        return transitions
+
+    # Vision prediction (kept for compatibility)
+    def predict_image(self, image_path):
+        if not self.vision_model: return "Model not found", 0.0
+        img = Image.open(image_path).convert("RGB")
+        tf = transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize([0.485]*3, [0.229]*3)])
+        with torch.no_grad():
+            out = self.vision_model(tf(img).unsqueeze(0).to(self.device))
+            conf, idx = torch.max(torch.nn.functional.softmax(out, dim=1), 1)
+        return VISION_CLASSES[idx.item()], conf.item()