🧠 Add complete launch kit with protected core and demo

.gitignore

@@ -0,0 +1,4 @@
+perceive/
+perceive_protected_sdk.zip
+*.csv
+*.ipynb_checkpoints/

LICENSE.txt

@@ -0,0 +1,13 @@
+Perceive AI PROTECTED LICENSE
+
+Copyright (c) 2025 Perceive AI LLC
+
+This software is licensed, not sold. Redistribution, reverse engineering,
+resale, sublicensing, or modification of any kind without written
+permission from Perceive AI LLC is strictly prohibited.
+
+Commercial use is allowed only with a valid license purchased under
+the Developer, Pro, or Enterprise tiers. See pricing.md or contact
+sales@perceive-ai.com for more information.
+
+All rights reserved.

README.md

@@ -0,0 +1,28 @@
+---
+title: Perceive PhaseFormer Demo
+emoji: 🧠
+colorFrom: blue
+colorTo: orange
+sdk: gradio
+app_file: app.py
+license: mit
+pinned: false
+tags:
+  - transformer
+  - memory
+  - decay
+  - reasoning
+---
+
+[![Hugging Face](https://img.shields.io/badge/view_on-HuggingFace-orange?logo=huggingface)](https://huggingface.co/PerceiveAI/perceive-phaseformer)
+
+# Perceive PhaseFormer + MemoryCore
+
+This is a time-aware neural core with two architectures:
+- `PhaseFormer` (MLP-based)
+- `PhaseFormerTransformerLayer` (Attention + decay + phase gating)
+
+Includes optional PerceiveFlow system for time-decayed memory tracking.
+
+Contact: sales@perceive-ai.com  
+License required for commercial use.

app.py

@@ -0,0 +1,28 @@
+import gradio as gr
+import torch
+from phaseformer import PhaseFormerWrapper
+
+def run_phaseformer(mode, seq_len, batch_size, input_dim, t):
+    model = PhaseFormerWrapper(mode=mode, input_dim=input_dim)
+    x = torch.randn(seq_len, batch_size, input_dim)
+    out = model(x, t)
+    return f"Output shape: {tuple(out.shape)}"
+
+iface = gr.Interface(
+    fn=run_phaseformer,
+    inputs=[
+        gr.Radio(["mlp", "transformer"], label="Select Model"),
+        gr.Slider(1, 128, value=10, label="Sequence Length"),
+        gr.Slider(1, 64, value=2, label="Batch Size"),
+        gr.Slider(1, 512, value=64, label="Input Dimension"),
+        gr.Slider(0.0, 10.0, value=5.0, step=0.1, label="Time Step (t)")
+    ],
+    outputs="text",
+    title="🧠 Perceive PhaseFormer Demo",
+    description="""
+Choose model mode and input specs. Outputs the shape of the result.
+    """
+)
+
+if __name__ == "__main__":
+    iface.launch()

phaseformer.py

@@ -0,0 +1,38 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class PhaseFormerTransformerLayer(nn.Module):
+    """
+    Transformer layer with phase-based temporal gating applied
+    to attention and feed-forward residual paths.
+
+    Args:
+        d_model (int): Input/output dimension.
+        nhead (int): Number of attention heads.
+        dim_feedforward (int): FFN hidden layer size.
+        dropout (float): Dropout probability.
+        decay_rate (float): Decay coefficient lambda.
+    """
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, decay_rate=0.1):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.decay_rate = decay_rate
+        self.phase_proj = nn.Linear(d_model, d_model)
+
+    def forward(self, src, t: float):
+        D_t = math.exp(-self.decay_rate * t)
+        phase = self.phase_proj(src)
+        g = D_t * torch.sin(phase)
+
+        attn_out, _ = self.self_attn(src, src, src)
+        src2 = self.norm1(src + g * attn_out)
+
+        ff = self.linear2(self.dropout(F.relu(self.linear1(src2))))
+        return self.norm2(src2 + g * ff)