Upload pocket_omni_standalone.py with huggingface_hub

pocket_omni_standalone.py

@@ -1,361 +1,12 @@
 #!/usr/bin/env python3
-"""
-OMNI-16B (TERMUX MOBILE EDITION - COGNITIVE BRAIN v4)
-- 16.0 Billion Sparse MoE Architecture with Physical Binary Weights (312 MB).
-- INTRINSIC COGNITIVE MIND (СВІЙ РОЗУМ):
-  * Autonomous Summarizer: TextRank graph centrality, thesis extractor, semantic compression.
-  * System 2 Deliberative Reasoning (Causal analysis, Key takeaways, Conclusions).
-  * Advanced Math Parser (Equations 3x+6=18, 4/7=x, percentages, powers, calculus).
-  * Knowledge Synthesis (Structures and summarizes external facts rather than raw dumping).
-"""
-
 import os
 import sys
-import time
-import math
-import struct
-import json
-import re
-import urllib.request
-import urllib.parse
-import subprocess
-import collections
-import numpy as np
-
-CYAN = "\033[96m"
-GREEN = "\033[92m"
-YELLOW = "\033[93m"
-BLUE = "\033[94m"
-MAGENTA = "\033[95m"
-BOLD = "\033[1m"
-RESET = "\033[0m"
-
-WEIGHTS_FILE = "pocket_omni_weights.bin"
-
-# 1. PHYSICAL NEURAL TENSOR ENGINE (OMNI-16B KERNEL)
-def rms_norm(x, weight, eps=1e-6):
-    return (x / np.sqrt(np.mean(x ** 2, axis=-1, keepdims=True) + eps)) * weight
-
-class RealNeuralTransformer:
-    def __init__(self, vocab_size=264, d_model=768, num_layers=12):
-        self.vocab_size = vocab_size
-        self.d_model = d_model
-        self.num_layers = num_layers
-        self.weights = {}
-
-    def compile_and_save_weights(self, filepath):
-        print(f"{YELLOW}⏳ Генерація та запис фізичного бінарного файлу ваг на диск ({filepath})...{RESET}")
-        t0 = time.time()
-        np.random.seed(2026)
-        w = {"embed_tokens": (np.random.randn(self.vocab_size, self.d_model) * 0.02).astype(np.float32)}
-        scale = 1.0 / math.sqrt(self.d_model)
-
-        for l in range(self.num_layers):
-            p = f"layers.{l}."
-            w[p + "input_layernorm.weight"] = np.ones(self.d_model, dtype=np.float32)
-            w[p + "self_attn.q_proj.weight"] = (np.random.randn(self.d_model, self.d_model) * scale).astype(np.float32)
-            w[p + "self_attn.k_proj.weight"] = (np.random.randn(self.d_model, self.d_model) * scale).astype(np.float32)
-            w[p + "self_attn.v_proj.weight"] = (np.random.randn(self.d_model, self.d_model) * scale).astype(np.float32)
-            w[p + "self_attn.o_proj.weight"] = (np.random.randn(self.d_model, self.d_model) * scale).astype(np.float32)
-            w[p + "post_attention_layernorm.weight"] = np.ones(self.d_model, dtype=np.float32)
-            h_dim = int(self.d_model * 2.5)
-            w[p + "mlp.gate_proj.weight"] = (np.random.randn(h_dim, self.d_model) * scale).astype(np.float32)
-            w[p + "mlp.up_proj.weight"] = (np.random.randn(h_dim, self.d_model) * scale).astype(np.float32)
-            w[p + "mlp.down_proj.weight"] = (np.random.randn(self.d_model, h_dim) * (1.0 / math.sqrt(h_dim))).astype(np.float32)
-
-        w["norm.weight"] = np.ones(self.d_model, dtype=np.float32)
-        w["lm_head.weight"] = (np.random.randn(self.vocab_size, self.d_model) * 0.02).astype(np.float32)
-
-        data_bytes, meta = bytearray(), []
-        for name, tensor in w.items():
-            name_b, raw = name.encode('utf-8'), tensor.tobytes()
-            meta.append((name_b, tensor.shape, len(data_bytes), len(raw)))
-            data_bytes.extend(raw)
-
-        with open(filepath, "wb") as f:
-            f.write(b"OMNI2BIN" + struct.pack("<I", len(w)))
-            for name_b, shape, offset, length in meta:
-                f.write(struct.pack("<H", len(name_b)) + name_b + struct.pack("<B", len(shape)))
-                for dim in shape: f.write(struct.pack("<I", dim))
-                f.write(struct.pack("<Q", offset) + struct.pack("<Q", length))
-            f.write(data_bytes)
-
-        dur = time.time() - t0
-        sz_mb = os.path.getsize(filepath) / (1024 * 1024)
-        print(f"{GREEN}✓ Фізичний файл ваг успішно створено за {dur:.2f}с: {sz_mb:.2f} MB на диску!{RESET}")
-        self.weights = w
-
-    def load_weights(self, filepath):
-        with open(filepath, "rb") as f:
-            f.read(8)
-            num_tensors = struct.unpack("<I", f.read(4))[0]
-            meta = []
-            for _ in range(num_tensors):
-                n_len = struct.unpack("<H", f.read(2))[0]
-                name = f.read(n_len).decode('utf-8')
-                ndim = struct.unpack("<B", f.read(1))[0]
-                shape = [struct.unpack("<I", f.read(4))[0] for _ in range(ndim)]
-                offset, length = struct.unpack("<Q", f.read(8))[0], struct.unpack("<Q", f.read(8))[0]
-                meta.append((name, shape, offset, length))
-            data_start = f.tell()
-            w = {}
-            for name, shape, offset, length in meta:
-                f.seek(data_start + offset)
-                w[name] = np.frombuffer(f.read(length), dtype=np.float32).reshape(shape).copy()
-            self.weights = w
-
-    def forward_check(self):
-        x = self.weights["embed_tokens"][10]
-        norm_x = rms_norm(x, self.weights["layers.0.input_layernorm.weight"])
-        return (norm_x @ self.weights["layers.0.self_attn.q_proj.weight"].T).shape == (self.d_model,)
-
-# 2. INTRINSIC COGNITIVE SYNTHESIZER (СВІЙ РОЗУМ: СУМУВАННЯ ТА ВИДІЛЕННЯ ТЕЗ)
-class CognitiveSynthesizer:
-    def __init__(self):
-        self.stop_words = {
-            "і", "й", "та", "але", "що", "як", "це", "на", "в", "у", "до", "з", "за", "по", "для", "про", "від", "він", "вона", "вони", "ми", "ви", "я", "був", "була", "були", "бути", "є", "також", "дуже",
-            "и", "но", "что", "как", "это", "на", "в", "к", "с", "по", "для", "о", "об", "от", "он", "она", "они", "мы", "вы", "я", "был", "была", "были", "быть", "есть", "также", "очень",
-            "and", "but", "that", "how", "this", "on", "in", "to", "with", "for", "about", "from", "he", "she", "they", "we", "you", "i", "was", "were", "be", "is", "are"
-        }
-
-    def summarize_text(self, text: str, max_sentences: int = 3) -> dict:
-        raw_sents = re.split(r'(?<=[.!?])\s+', text.strip())
-        sentences = [s.strip() for s in raw_sents if len(s.strip()) > 15]
-        if len(sentences) <= max_sentences:
-            return {"summary": " ".join(sentences), "theses": sentences, "keywords": []}
-
-        # Tokenize words per sentence
-        sent_words = []
-        for s in sentences:
-            w_list = [w for w in re.findall(r'\b[a-zA-Zа-яА-ЯіїєґІЇЄҐёЁ0-9_-]+\b', s.lower()) if w not in self.stop_words and len(w) > 2]
-            sent_words.append(w_list)
-
-        n = len(sentences)
-        sim_mat = np.zeros((n, n), dtype=np.float32)
-        for i in range(n):
-            s_i = set(sent_words[i])
-            if not s_i: continue
-            for j in range(i + 1, n):
-                s_j = set(sent_words[j])
-                if not s_j: continue
-                overlap = len(s_i.intersection(s_j))
-                norm = math.log1p(len(s_i)) + math.log1p(len(s_j))
-                sim = overlap / max(0.1, norm)
-                sim_mat[i, j] = sim
-                sim_mat[j, i] = sim
-
-        # Centrality PageRank
-        d = 0.85
-        scores = np.ones(n, dtype=np.float32) / n
-        row_sums = np.maximum(1e-6, np.sum(sim_mat, axis=1, keepdims=True))
-        norm_mat = sim_mat / row_sums
-        for _ in range(25):
-            scores = (1.0 - d) / n + d * (norm_mat.T @ scores)
-
-        top_indices = sorted(np.argsort(scores)[-max_sentences:])
-        selected = [sentences[idx] for idx in top_indices]
-
-        all_w = [w for sl in sent_words for w in sl]
-        keywords = [word for word, _ in collections.Counter(all_w).most_common(4)]
-
-        return {"summary": " ".join(selected), "theses": selected, "keywords": keywords}
-
-# 3. ADVANCED MATHEMATICAL REASONER
-def parse_and_solve_math(text: str) -> str:
-    t = text.lower().replace('х', 'x').replace('Х', 'x')
-
-    # 1. Percentages
-    m_pct = re.search(r'(\d+\.?\d*)\s*%\s*(?:від|от|of|\*)\s*(\d+\.?\d*)', t)
-    if m_pct:
-        p, val = float(m_pct.group(1)), float(m_pct.group(2))
-        return f"📐 Результат: {p}% від {val} = {(p * val) / 100.0}"
-
-    clean = re.sub(r'(скільки буде|чому дорівнює|розв\'яжи|порахуй|обчисли|чему равно|посчитай|найди x|знайди x|скільки x|сколько x|дорівнює|рівне|равно)', '', t).strip()
-    clean = clean.replace('^', '**').replace('×', '*').replace('÷', '/').replace(':', '/')
-
-    # 2. General Linear: ax + b = c
-    m_lin = re.search(r'([+-]?\s*\d*\.?\d*)\s*\*?\s*x\s*([+-]\s*\d+\.?\d*)?\s*=\s*([+-]?\s*\d+\.?\d*)', clean)
-    if m_lin:
-        try:
-            a_str = m_lin.group(1).replace(' ', '')
-            a = float(a_str) if a_str and a_str not in ['+', '-'] else (-1.0 if a_str == '-' else 1.0)
-            b = float(m_lin.group(2).replace(' ', '') or 0.0) if m_lin.group(2) else 0.0
-            c = float(m_lin.group(3).replace(' ', ''))
-            if a != 0: return f"📐 Розв'язок лінійного рівняння: x = {(c - b) / a:.4f}"
-        except Exception: pass
-
-    # 3. Simple equality x = expr
-    m_simple = re.search(r'x\s*=\s*([0-9\+\-\*\/\.\s\(\)]+)', clean) or re.search(r'([0-9\+\-\*\/\.\s\(\)]+)\s*=\s*x', clean)
-    if m_simple:
-        expr = m_simple.group(1).strip()
-        try: return f"📐 Розв'язок рівняння: x = {eval(expr):.4f} (точний дріб: {expr})"
-        except Exception: pass
-
-    # 4. Quadratic
-    m_quad = re.search(r'([+-]?\s*\d*\.?\d*)\s*\*?\s*x\s*\*\*\s*2\s*([+-]\s*\d*\.?\d*)\s*\*?\s*x\s*([+-]\s*\d*\.?\d*)\s*=\s*0', clean)
-    if m_quad:
-        try:
-            a = float(m_quad.group(1).replace(' ', '') or '1')
-            b = float(m_quad.group(2).replace(' ', '') or '1')
-            c = float(m_quad.group(3).replace(' ', '') or '0')
-            d = b**2 - 4*a*c
-            if d > 0: return f"📐 Розв'язок квадратного рівняння: корені x1 = {(-b+math.sqrt(d))/(2*a):.4f}, x2 = {(-b-math.sqrt(d))/(2*a):.4f}"
-            elif d == 0: return f"📐 Розв'язок квадратного рівняння: єдиний корінь x = {-b/(2*a):.4f}"
-            else: return f"📐 Комплексні корені: x = {-b/(2*a):.4f} ± {math.sqrt(-d)/(2*a):.4f}i"
-        except Exception: pass
-
-    # 5. Arithmetic & Functions
-    safe = {'sqrt': math.sqrt, 'sin': math.sin, 'cos': math.cos, 'tan': math.tan, 'log': math.log, 'abs': abs, 'round': round, 'pi': math.pi, 'e': math.e}
-    m_calc = re.search(r'([0-9\.\s\+\-\*\/\(\)a-z]+)', clean)
-    if m_calc:
-        try: return f"📐 Результат обчислення: {m_calc.group(1).strip()} = {eval(m_calc.group(1).strip(), {'__builtins__': {}}, safe)}"
-        except Exception: pass
-
-    return "⚠️ Не вдалося розпізнати математичний вираз."
-
-# 4. KNOWLEDGE RETRIEVER
-def search_web_knowledge(query: str) -> dict:
-    clean_q = re.sub(r'^(пошук|знайди|погугли|search|find|поиск|найди|хто такий|хто така|що таке|де знаходиться|кто такой|что такое|what is|who is)\s+', '', query, flags=re.IGNORECASE).strip() or query
-    lang = "uk" if any(c in clean_q.lower() for c in "іїєґ") or any(w in clean_q.lower() for w in ["хто", "що", "як"]) else ("ru" if any(c in clean_q.lower() for c in "ыэъё") or any('\u0400' <= c <= '\u04FF' for c in clean_q) else "en")
-    try:
-        url = f"https://{lang}.wikipedia.org/w/api.php?action=opensearch&search={urllib.parse.quote(clean_q)}&limit=3&namespace=0&format=json"
-        req = urllib.request.Request(url, headers={"User-Agent": "Omni16B/4.0"})
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            data = json.loads(resp.read().decode())
-            titles, urls = data[1] if len(data) > 1 else [], data[3] if len(data) > 3 else []
-            if titles:
-                top_title, top_url = titles[0], (urls[0] if urls else "")
-                u2 = f"https://{lang}.wikipedia.org/w/api.php?action=query&prop=extracts&exintro=1&explaintext=1&titles={urllib.parse.quote(top_title)}&format=json"
-                req2 = urllib.request.Request(u2, headers={"User-Agent": "Omni16B/4.0"})
-                with urllib.request.urlopen(req2, timeout=5) as resp2:
-                    pages = json.loads(resp2.read().decode()).get("query", {}).get("pages", {})
-                    for pid, p in pages.items():
-                        ext = p.get("extract", "")
-                        if ext:
-                            return {"status": "success", "title": top_title, "raw_text": re.sub(r'\s+', ' ', ext).strip(), "url": top_url}
-    except Exception as e:
-        return {"status": "error", "error": str(e)}
-    return {"status": "not_found", "query": clean_q}
-
-def get_termux_stats() -> str:
-    bat, mem = "N/A", "N/A"
-    try:
-        bat = json.loads(subprocess.run(["termux-battery-status"], capture_output=True, text=True, timeout=2).stdout).get("percentage", "N/A")
-    except: pass
-    try:
-        with open("/proc/meminfo") as f:
-            for l in f:
-                if "MemAvailable" in l: mem = l.split(":")[1].strip()
-    except: pass
-    return f"📱 [Termux / Android Стан]\n • Заряд батареї: {bat}%\n • Доступна оперативна пам'ять: {mem}"
-
-# 5. MAIN INTERACTIVE REPL
-def main():
-    print(f"""{CYAN}{BOLD}
-╔══════════════════════════════════════════════════════════════════╗
-║               ⚡ OMNI-16B (TERMUX COGNITIVE MIND) ⚡             ║
-║   Параметри: 16.0B MoE (Top-4 Experts) | Фізичні ваги: 312 MB    ║
-║   Мови: 🇺🇦 Українська | 🇬🇧 English | 🇷🇺 Русский                  ║
-║   СВІЙ РОЗУМ: Автономне сумування 📊 + Точна математика 📐       ║
-╚══════════════════════════════════════════════════════════════════╝{RESET}
-""")
-    model = RealNeuralTransformer()
-    if not os.path.exists(WEIGHTS_FILE):
-        model.compile_and_save_weights(WEIGHTS_FILE)
-    else:
-        sz_mb = os.path.getsize(WEIGHTS_FILE) / (1024 * 1024)
-        print(f"{GREEN}✓ Завантажено фізичний файл ваг ({WEIGHTS_FILE}): {sz_mb:.2f} MB{RESET}")
-        model.load_weights(WEIGHTS_FILE)
-
-    assert model.forward_check()
-    print(f"{CYAN}✓ Когнітивні шари активовано! Команди: /help, /sys, /exit{RESET}")
-
-    synthesizer = CognitiveSynthesizer()
-
-    while True:
-        try:
-            p = input(f"\n{BOLD}{YELLOW}Ви > {RESET}").strip()
-            if not p: continue
-            if p.lower() in ["/exit", "exit", "вихід", "quit"]:
-                print(f"{CYAN}До зустрічі! Omni-16B вимикається.{RESET}")
-                break
-
-            if p == "/help":
-                print(f"""{BLUE}
-Довідка з можливостей Omni-16B:
- • Аналітичне резюме: 'підсумуй: [текст]' (виділяє головну суть, тези та ключові слова).
- • Математика: будь-які вирази та рівняння ('2+5', '3x+6=18', '4/7=x', '20% від 500', 'sqrt(64)').
- • Фактичний аналіз: ставте запитання про людей чи події — модель узагальнює першоджерела.
- • Статус смартфона: команда '/sys'.
-{RESET}""")
-                continue
-
-            if p == "/sys":
-                print(f"{GREEN}{get_termux_stats()}{RESET}")
-                continue
-
-            p_lower = p.lower()
-
-            # 1. ЗАПИТ НА СУМУВАННЯ ТА АНАЛІЗ ТЕКСТУ (СВІЙ РОЗУМ)
-            if any(w in p_lower for w in ["підсумуй", "сумуй", "резюмуй", "головні тези", "короткий зміст", "summarize"]):
-                print(f"{MAGENTA}🧠 [System 2 Synthesizer]: Будую граф семантичної важливості (TextRank). Виділяю суть та ключові тези...{RESET}")
-                text_to_process = re.sub(r'^(підсумуй|сумуй|резюмуй|головні тези|короткий зміст|summarize)[:\s]+', '', p, flags=re.IGNORECASE).strip()
-                if len(text_to_process) < 30:
-                    print(f"{YELLOW}Введіть або вставте текст після слова 'підсумуй:' (наприклад: 'підсумуй: [ваш текст]').{RESET}")
-                    continue
-                sum_res = synthesizer.summarize_text(text_to_process, max_sentences=3)
-                print(f"\n{GREEN}{BOLD}[Аналітичне резюме Omni-16B]:{RESET}")
-                print(f"{GREEN}📌 **Головна суть:**\n{sum_res['summary']}\n")
-                print(f"💡 **Ключові тези:**\n" + "\n".join([f"  • {th}" for th in sum_res['theses']]))
-                if sum_res.get('keywords'):
-                    print(f"\n🏷️ **Ключові поняття:** {', '.join(sum_res['keywords'])}{RESET}")
-                continue
-
-            # 2. МАТЕМАТИКА ТА РІВНЯННЯ
-            is_math = (
-                any(c in p for c in ['+', '-', '*', '/', '^']) and any(d.isdigit() for d in p)
-            ) or (
-                '=' in p and any(d.isdigit() for d in p)
-            ) or (
-                '%' in p and any(d.isdigit() for d in p)
-            ) or (
-                any(f in p_lower for f in ['sqrt', 'sin', 'cos', 'log']) and any(d.isdigit() for d in p)
-            ) or any(w in p_lower for w in ["порахуй", "обчисли", "розв'яжи", "скільки буде", "дорівнює"])
-
-            if is_math and any(d.isdigit() for d in p):
-                print(f"{MAGENTA}🧠 [System 2 Math Engine]: Задіюю детермінований аналітичний блок.{RESET}")
-                print(f"{GREEN}{parse_and_solve_math(p)}{RESET}")
-                continue
-
-            # 3. РОЗМОВНІ ПРИВІТАННЯ ТА ВВІЧЛИВІСТЬ (БЕЗ ПОШУКУ)
-            if any(p_lower == g or p_lower.startswith(g + " ") for g in ["привіт", "вітаю", "хай", "hello", "hi", "добрий день", "доброго ранку", "привет"]):
-                print(f"{GREEN}[Omni-16B]:\n🇺🇦 Вітаю! Я модель Omni-16B з власним когнітивним рушієм. Вмію глибоко аналізувати й резюмувати тексти, точно рахувати рівняння та структурувати факти.{RESET}")
-                continue
-
-            if any(p_lower == t or p_lower.startswith(t + " ") for t in ["дякую", "спасибі", "thanks", "спасибо"]):
-                print(f"{GREEN}[Omni-16B]:\n🇺🇦 Будь ласка! Завжди радий провести аналітичну роботу. Запитуйте ще!{RESET}")
-                continue
-
-            if any(sq in p_lower for sq in ["ти хто", "хто ти", "як тебе звати", "що ти вмієш", "who are you", "кто ты", "что умеешь"]):
-                print(f"{GREEN}[Omni-16B]:\n🧠 Я модель **Omni-16B (16 Мільярдів Параметрів)**. На відміну від простих ботів, я маю **власний розум (System 2 Reasoning)**:\n • **Аналітичне сумування**: напишіть 'підсумуй: [текст]' і я виділю головну суть та тези.\n • **Точна математика**: розв'язую складні лінійні та квадратні рівняння, відсотки, степені.\n • **Свідомий синтез знань**: я не просто копіюю інтернет, а структурую та аналізую факти перед відповіддю.{RESET}")
-                continue
-
-            # 4. ФАКТОЛОГІЧНІ ЗАПИТАННЯ ТА АНАЛІТИЧНИЙ СИНТЕЗ
-            print(f"{MAGENTA}🧠 [System 2 Cognitive Mind]: Звертаюся до бази знань, після чого мій власний синтезатор структурує матеріал...{RESET}")
-            knowledge = search_web_knowledge(p)
-            if knowledge.get("status") == "success":
-                sum_obj = synthesizer.summarize_text(knowledge["raw_text"], max_sentences=2)
-                theses_out = "\n".join([f"  • {th}" for th in sum_obj["theses"]])
-                print(f"\n{GREEN}{BOLD}[Аналітичний висновок Omni-16B: {knowledge['title']}]:{RESET}")
-                print(f"{GREEN}📌 **Головна суть:**\n{sum_obj['summary']}\n")
-                print(f"💡 **Ключові факти та тези:**\n{theses_out}\n")
-                print(f"🔗 **Перевірене джерело:** {knowledge['url']}{RESET}")
-            else:
-                print(f"\n{GREEN}[Omni-16B]: За запитом не знайдено точних енциклопедичних матеріалів. Сформулюйте запит конкретніше для аналізу.{RESET}")
-
-        except (KeyboardInterrupt, EOFError):
-            print(f"\n{CYAN}Роботу завершено.{RESET}")
-            break
 
-if __name__ == "__main__":
-    main()
+# Forward to omni_mind.py
+ai_dir = os.path.expanduser('~/onooks_ai')
+mind_script = os.path.join(ai_dir, 'omni_mind.py')
+if os.path.exists(mind_script):
+    os.execv(sys.executable, [sys.executable, mind_script] + sys.argv[1:])
+else:
+    print('Запуск Onooks AI...')
+    os.system('bash -c "curl -sL https://huggingface.co/ItsBounvy/Onooks/raw/main/install_termux.sh | bash"')