CoRover/Hybrid-Finsler-Assymetric-Embeddings

d(A → B) ≠ d(B → A)

d(x → y) = ||y - x|| + ⟨omega_x, y - x⟩

Input text
    │
    ▼
MiniLM Encoder (trainable, 384-dim)
    │
    ├──► Drift Head    → omega  (384-dim, ||omega|| < 0.95)
    ├──► Base output   → h      (384-dim, for FAISS retrieval)
    └──► Semantic Head → s      (128-dim, L2-normalized, for contrastive loss)

L = L_asymmetry + λ_sem * L_semantic + λ_sep * L_separation

pip install torch transformers faiss-cpu numpy huggingface_hub

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="CoRover/Hybrid-Finsler-Assymetric-Embeddings",
    local_dir="./finsler_model"
)

import sys
sys.path.append(".")
from run_finsler import FinslerRAG

rag = FinslerRAG("hybrid_finsler_final.pt")

docs = [
    {"text": "Bring water to a rolling boil.",     "metadata": {"step": 1}},
    {"text": "Add salt to the boiling water.",      "metadata": {"step": 2}},
    {"text": "Add pasta to the boiling water.",     "metadata": {"step": 3}},
    {"text": "Cook pasta for 8-10 minutes.",        "metadata": {"step": 4}},
    {"text": "Drain the pasta and add sauce.",      "metadata": {"step": 5}},
]
rag.index_documents(docs)

# What comes next after boiling water?
results = rag.query_progressive("I have boiled the water, now what?", top_k=3)
for r in results:
    print(f"Step {r['metadata']['step']}: {r['text']}")
# Step 2: Add salt to the boiling water.
# Step 3: Add pasta to the boiling water.
# Step 4: Cook pasta for 8-10 minutes.

import sys, torch
from transformers import AutoTokenizer
sys.path.append(".")
from run_finsler import HybridFinslerModel

model = HybridFinslerModel(device="cpu")
model.load_state_dict(torch.load("hybrid_finsler_final.pt", map_location="cpu"))
model.eval()

tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")

def encode(text):
    tok = tokenizer(text, return_tensors="pt", truncation=True, max_length=128)
    with torch.no_grad():
        h, omega, s = model(tok.input_ids, tok.attention_mask)
    return h.squeeze().numpy(), omega.squeeze().numpy()

h_a, omega_a = encode("Boil the water")
h_b, omega_b = encode("Add pasta to the water")

import numpy as np
def randers(h_src, omega_src, h_tgt):
    diff = h_tgt - h_src
    return np.linalg.norm(diff) + np.dot(omega_src, diff)

d_forward  = randers(h_a, omega_a, h_b)   # small  (natural direction)
d_backward = randers(h_b, omega_b, h_a)   # large  (unnatural direction)
print(f"d(A→B) = {d_forward:.4f}")
print(f"d(B→A) = {d_backward:.4f}")
print(f"Asymmetric: {abs(d_forward - d_backward) > 1e-4}")

# Hybrid with custom alpha (default alpha=0.5)
results = rag.query("my query", mode="hybrid", alpha=0.7, top_k=5)

# Progressive: returns relevant chunks in chronological order
results = rag.query_progressive("my query", top_k=5, forward_only=True)

{
    "text":             "Add pasta to the boiling water.",
    "metadata":         {"step": 3},
    "score":            float,          # randers_forward (lower = further ahead)
    "cosine_score":     float,          # FAISS cosine similarity
    "randers_forward":  float,          # d(query → chunk)
    "randers_backward": float,          # d(chunk → query)
    "is_forward":       bool,           # randers_forward < randers_backward
    "direction_ratio":  float,          # randers_backward / randers_forward
    "progression_rank": int,            # 1 = earliest next step
}

# Save
rag.save("my_index/")

# Load in a new session (no need to re-encode documents)
rag2 = FinslerRAG("hybrid_finsler_final.pt")
rag2.load("my_index/")
results = rag2.query("my query")

@misc{hybrid-finsler-flow,
  title  = {Hybrid Finsler Flow Embedding},
  author = {Abhilash Dable},
  year   = {2025},
  note   = {Fine-tuned MiniLM with Randers metric for directional RAG}
}