dineth554/sri-lanka-location-intelligence

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np
import sqlite3
import json

# Load the model
model = SentenceTransformer('deathlegionteam/sri-lanka-location-intelligence')

# Load FAISS index and ID mapping
index = faiss.read_index('faiss_index_large.bin')
id_mapping = np.load('id_mapping_large.npy', allow_pickle=True)

# Connect to database
conn = sqlite3.connect('srilanka_places.db')
cursor = conn.cursor()

def search_locations(query, top_k=10):
    """Search any location in Sri Lanka by semantic query."""
    # Encode query
    query_vec = model.encode(['query: ' + query], normalize_embeddings=True)
    
    # Search FAISS index
    distances, indices = index.search(query_vec.astype(np.float32), top_k)
    
    # Fetch results from database
    results = []
    for i, idx in enumerate(indices[0]):
        location_id = id_mapping[idx]
        cursor.execute("SELECT * FROM locations WHERE id=?", (int(location_id),))
        row = cursor.fetchone()
        if row:
            # Convert sqlite3.Row to dict
            cols = [d[0] for d in cursor.description]
            location = dict(zip(cols, row))
            location['similarity'] = float(distances[0][i])
            results.append(location)
    
    return results

# Examples
results = search_locations("police station in Colombo")
for r in results[:5]:
    print(f"{r['name']} — {r['category']} ({r['latitude']}, {r['longitude']})")

results = search_locations("Buddhist temple near Kandy")
results = search_locations("hospital with emergency services")
results = search_locations("Colombo 7 restaurant")

def search_by_category(query, category, top_k=10):
    """Search within a specific category."""
    query_vec = model.encode(['query: ' + query], normalize_embeddings=True)
    distances, indices = index.search(query_vec.astype(np.float32), top_k * 3)
    
    results = []
    for idx in indices[0]:
        location_id = id_mapping[idx]
        cursor.execute("SELECT * FROM locations WHERE id=? AND category=?", 
                      (int(location_id), category))
        row = cursor.fetchone()
        if row:
            cols = [d[0] for d in cursor.description]
            location = dict(zip(cols, row))
            location['similarity'] = float(distances[0][list(indices[0]).index(idx)])
            results.append(location)
        if len(results) >= top_k:
            break
    return results

# Find hospitals in the Western Province
results = search_by_category("government hospital", "hospital", 5)

import math

def haversine(lat1, lon1, lat2, lon2):
    """Calculate distance in km between two coordinates."""
    R = 6371
    dlat = math.radians(lat2 - lat1)
    dlon = math.radians(lon2 - lon1)
    a = math.sin(dlat/2)**2 + math.cos(math.radians(lat1)) * \
        math.cos(math.radians(lat2)) * math.sin(dlon/2)**2
    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))

def find_nearby(lat, lon, radius_km=5, limit=50):
    """Find locations near a point."""
    # Bounding box pre-filter
    lat_delta = radius_km / 111.0
    lon_delta = radius_km / (111.0 * abs(math.cos(math.radians(lat))) + 0.001)
    
    cursor.execute("""
        SELECT * FROM locations 
        WHERE latitude BETWEEN ? AND ?
        AND longitude BETWEEN ? AND ?
        ORDER BY ABS(latitude - ?) + ABS(longitude - ?)
        LIMIT ?
    """, (lat - lat_delta, lat + lat_delta,
          lon - lon_delta, lon + lon_delta,
          lat, lon, limit * 2))
    
    rows = cursor.fetchall()
    cols = [d[0] for d in cursor.description]
    
    results = []
    for row in rows:
        loc = dict(zip(cols, row))
        dist = haversine(lat, lon, loc['latitude'], loc['longitude'])
        if dist <= radius_km:
            loc['distance_km'] = round(dist, 2)
            results.append(loc)
            if len(results) >= limit:
                break
    
    return results

# Find everything near Colombo Fort
nearby = find_nearby(6.9344, 79.8428, radius_km=2)

User Query (in any language)
        ↓
multilingual-e5-large (1024-dim embedding)
        ↓
FAISS IVFFlat Index (nlist=200, cosine similarity)
        ↓
SQLite Database → Location Name + Coordinates + Category + Tags
        ↓
Structured Results with similarity scores