Upload 4 files

Dockerfile

@@ -0,0 +1,28 @@
+# Use lightweight Python base
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy files
+COPY . .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create cache directory and make it writable for non-root
+RUN mkdir -p /app/hf_cache && chmod -R 777 /app/hf_cache
+
+# Set environment variables for Hugging Face cache
+ENV HF_HOME=/app/hf_cache
+ENV TRANSFORMERS_CACHE=/app/hf_cache
+
+# Expose Space port
+EXPOSE 7860
+
+# Switch to non-root user
+RUN useradd -m appuser
+USER appuser
+
+# Run Flask directly (no Gunicorn)
+CMD ["python", "api_inference.py"]

api_inference.py

@@ -0,0 +1,132 @@
+import os
+import torch
+import torch.nn as nn
+from flask import Flask, request, jsonify
+from transformers import (
+    AutoTokenizer,
+    AutoModel,
+    AutoConfig,
+    PretrainedConfig,
+    PreTrainedModel,
+)
+
+# ============================================================
+# Redirect Hugging Face cache to /app/hf_cache (always writable)
+CACHE_DIR = "/app/hf_cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+os.environ["HF_HOME"] = CACHE_DIR
+os.environ["TRANSFORMERS_CACHE"] = CACHE_DIR
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+MODEL_DIR = "./"
+PORT = int(os.environ.get("PORT", 7860))
+
+app = Flask(__name__)
+
+
+# ============================================================
+# Register Custom SNP Architecture
+# ============================================================
+class CustomSNPConfig(PretrainedConfig):
+    model_type = "custom_snp"
+
+
+class CustomSNPModel(PreTrainedModel):
+    config_class = CustomSNPConfig
+
+    def __init__(self, config):
+        super().__init__(config)
+        hidden_size = getattr(config, "hidden_size", 768)
+        # Mirror and Prism heads
+        self.encoder = nn.Linear(hidden_size, hidden_size)
+        self.mirror_head = nn.Sequential(nn.Linear(hidden_size, hidden_size), nn.Tanh())
+        self.prism_head = nn.Sequential(nn.Linear(hidden_size, hidden_size), nn.Tanh())
+        self.projection = nn.Linear(hidden_size, 6)
+
+    def forward(self, input_ids=None, attention_mask=None, **kwargs):
+        # Simulate encoded representations
+        x = self.encoder(input_ids.float()) if input_ids is not None else None
+        x = self.mirror_head(x)
+        x = self.prism_head(x)
+        return self.projection(x)
+
+
+# Register model so AutoModel recognizes it
+AutoConfig.register("custom_snp", CustomSNPConfig)
+AutoModel.register(CustomSNPConfig, CustomSNPModel)
+
+
+# ============================================================
+# Load Model & Tokenizer
+# ============================================================
+try:
+    print("Loading model from:", MODEL_DIR)
+    config = AutoConfig.from_pretrained(MODEL_DIR, trust_remote_code=True)
+
+    # Try loading tokenizer; fallback if not mapped
+    from transformers import RobertaTokenizer
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR)
+    except Exception:
+        print("⚠️ Falling back to default RoBERTa tokenizer.")
+        tokenizer = RobertaTokenizer.from_pretrained("roberta-base")
+
+    model = AutoModel.from_pretrained(MODEL_DIR, config=config, trust_remote_code=True)
+    model.eval()
+    print("✅ Custom SNP model loaded successfully.")
+
+except Exception as e:
+    print("❌ Error loading custom model:", e)
+    raise e
+
+
+# ============================================================
+# Flask API Routes
+# ============================================================
+@app.route("/", methods=["GET"])
+def home():
+    return jsonify({"status": "SNP Universal Embedding API running"})
+
+
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({"status": "healthy"})
+
+
+@app.route("/embed", methods=["POST"])
+def embed():
+    data = request.get_json(force=True)
+    text = data.get("text", "")
+    if not text:
+        return jsonify({"error": "Text is required"}), 400
+
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        embeddings = model(**inputs)
+    if hasattr(embeddings, "last_hidden_state"):
+        embeddings = embeddings.last_hidden_state.mean(dim=1)
+    elif isinstance(embeddings, tuple):
+        embeddings = embeddings[0]
+    return jsonify({"embedding": embeddings.tolist()})
+
+
+@app.route("/reason", methods=["POST"])
+def reason():
+    data = request.get_json(force=True)
+    premise = data.get("premise", "")
+    hypothesis = data.get("hypothesis", "")
+    combined = f"{premise} {hypothesis}"
+    inputs = tokenizer(combined, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        output = model(**inputs)
+    score = float(output.mean().item())
+    return jsonify({"reasoning_score": score})
+
+
+# ============================================================
+# Run Server
+# ============================================================
+if __name__ == "__main__":
+    print(f"🚀 Starting SNP Universal Embedding API on port {PORT}")
+    app.run(host="0.0.0.0", port=PORT)
+

requirements.txt

@@ -0,0 +1,7 @@
+# requirements.txt
+torch
+transformers
+sentence-transformers
+flask
+numpy
+scikit-learn

snp_universal_embedding.py

@@ -0,0 +1,62 @@
+import torch
+import torch.nn as nn
+from transformers import AutoModel, AutoTokenizer
+import os, json
+
+print("✅ Environment ready")
+print("Torch:", torch.__version__)
+
+# ============================================================
+# Custom SNP Model Architecture
+# ============================================================
+class CustomSNPModel(nn.Module):
+    def __init__(self, base_model="bert-base-uncased"):
+        super().__init__()
+        self.shared_encoder = AutoModel.from_pretrained(base_model)
+        hidden_size = self.shared_encoder.config.hidden_size
+        self.mirror_head = nn.Sequential(nn.Linear(hidden_size, hidden_size), nn.Tanh())
+        self.prism_head  = nn.Sequential(nn.Linear(hidden_size, hidden_size), nn.Tanh())
+        self.projection  = nn.Linear(hidden_size, 6)
+
+    def forward(self, input_ids, attention_mask=None, token_type_ids=None):
+        outputs = self.shared_encoder(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            token_type_ids=token_type_ids
+        )
+        cls = outputs.last_hidden_state[:, 0, :]
+        proj = self.projection(cls)
+        return proj
+
+print("✅ SNP architecture defined.")
+
+# ============================================================
+# Load Checkpoint (optional; comment out if not available)
+# ============================================================
+ckpt_path = "pytorch_model.bin"
+if os.path.exists(ckpt_path):
+    print(f"Loading weights from {ckpt_path}")
+    state_dict = torch.load(ckpt_path, map_location="cpu")
+    clean_state_dict = {k.replace("module.", ""): v for k, v in state_dict.items()}
+
+    model = CustomSNPModel(base_model="bert-base-uncased")
+    model.load_state_dict(clean_state_dict, strict=False)
+    print("✅ Checkpoint loaded successfully.")
+else:
+    print("⚠️ No checkpoint found, initializing new model.")
+    model = CustomSNPModel()
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+
+# ============================================================
+# Example Inference
+# ============================================================
+text = "A student must decide between a scholarship and their family."
+inputs = tokenizer(text, return_tensors="pt")
+inputs.pop("token_type_ids", None)
+
+with torch.no_grad():
+    output = model(**inputs)
+
+print("✅ Embedding generated successfully.")
+print("Embedding shape:", output.shape if hasattr(output, "shape") else type(output))