add vdb

vdb/.gitignore

@@ -0,0 +1,3 @@
+volumes
+minio_data
+milvus_data

vdb/api.py

@@ -0,0 +1,514 @@
+"""
+FastAPI server for Sumobot with Milvus Vector Search
+Real-time action retrieval using similarity search
+"""
+
+import re
+import platform
+import time
+from typing import Dict, Optional, List
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+import numpy as np
+from pymilvus import connections, Collection
+
+# ==================== Configuration ====================
+MILVUS_HOST = "127.0.0.1"
+MILVUS_PORT = "19530"
+COLLECTION_NAME = "sumobot_states"
+TOP_K = 1  # Number of similar states to retrieve
+NPROBE = 16  # Search parameter for IVF_FLAT index
+
+print("="*70)
+print("🤖 Sumobot Milvus Vector Search API Server")
+print("="*70)
+print(f"Platform: {platform.system()} {platform.machine()}")
+print(f"Milvus: {MILVUS_HOST}:{MILVUS_PORT}")
+print(f"Collection: {COLLECTION_NAME}")
+print("="*70)
+
+# ==================== Connect to Milvus ====================
+print("\n⏳ Connecting to Milvus...")
+start_time = time.time()
+
+try:
+    connections.connect("default", host=MILVUS_HOST, port=MILVUS_PORT)
+    col = Collection(COLLECTION_NAME)
+    col.load()
+    
+    load_time = time.time() - start_time
+    num_entities = col.num_entities
+    
+    print(f"✅ Connected to Milvus in {load_time:.2f}s")
+    print(f"📊 Collection has {num_entities} entities\n")
+    
+except Exception as e:
+    print(f"❌ Failed to connect to Milvus: {e}")
+    print("\nMake sure:")
+    print(f"  1. Milvus is running at {MILVUS_HOST}:{MILVUS_PORT}")
+    print(f"  2. Collection '{COLLECTION_NAME}' exists")
+    print("  3. pymilvus is installed: pip install pymilvus")
+    exit(1)
+
+# ==================== State Encoding ====================
+def encode_state(angle: float, angle_score: float, dist_score: float, 
+                 near_score: float, facing: float) -> np.ndarray:
+    """
+    Encode game state into 5D vector
+    
+    Args:
+        angle: AngleToEnemy (degrees, normalized to [-1, 1])
+        angle_score: AngleToEnemyScore [0, 1]
+        dist_score: DistanceToEnemyScore [0, 1]
+        near_score: NearBorderArenaScore [0, 1]
+        facing: FacingToArena [-1, 1]
+    
+    Returns:
+        5D numpy array [angle_normalized, angle_score, dist_score, near_score, facing]
+    """
+    # Normalize angle from [-180, 180] to [-1, 1]
+    angle_normalized = angle / 180.0
+    
+    return np.array([
+        angle_normalized,
+        angle_score,
+        dist_score,
+        near_score,
+        facing
+    ], dtype=np.float32)
+
+def parse_state_string(state_str: str) -> Dict[str, float]:
+    """
+    Parse state string into dictionary
+    
+    Example input: "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99"
+    Returns: {"AngleToEnemy": 7.77, "AngleToEnemyScore": 0.99, ...}
+    """
+    state_dict = {}
+    
+    # Remove trailing punctuation from entire string
+    state_str = state_str.rstrip('.,;')
+    
+    for part in state_str.split(","):
+        part = part.strip()
+        if "=" in part:
+            key, value = part.split("=", 1)  # Split only on first '='
+            # Clean up value: remove trailing periods, spaces, etc.
+            value_clean = value.strip().rstrip('.')
+            try:
+                state_dict[key.strip()] = float(value_clean)
+            except ValueError as e:
+                raise ValueError(f"Cannot parse '{key.strip()}={value}' - invalid float value: {e}")
+    
+    return state_dict
+
+# ==================== Action Parser ====================
+def parse_action(output: str) -> Dict[str, Optional[float]]:
+    """
+    Parse action string into dictionary
+    
+    Expected format: "FWD 1.5, TR 0.8" or "SK, DS 2.0"
+    Returns: {"Accelerate": 1.5, "TurnRight": 0.8} or {"Skill": None, "Dash": 2.0}
+    """
+    action_map = {
+        "SK": "Skill",
+        "DS": "Dash",
+        "FWD": "Accelerate",
+        "TL": "TurnLeft",
+        "TR": "TurnRight",
+    }
+    
+    actions: Dict[str, Optional[float]] = {}
+    
+    # Split by comma and process each action
+    for part in [p.strip() for p in output.split(",")]:
+        if not part:
+            continue
+            
+        name = part
+        duration = None
+        
+        # Try to extract duration (e.g., "FWD 1.5" -> name="FWD", duration=1.5)
+        direct_match = re.match(r"^([A-Za-z]+)\s*([\d.]+)$", part)
+        if direct_match:
+            name = direct_match.group(1).strip()
+            duration = float(direct_match.group(2))
+        
+        # Normalize shorthand to full action name
+        for short, full in action_map.items():
+            if name.upper().startswith(short):
+                name = full
+                break
+        
+        actions[name] = duration
+    
+    return actions
+
+# ==================== Vector Search Function ====================
+def query_action(angle: float, angle_score: float, dist_score: float, 
+                 near_score: float, facing: float, top_k: int = TOP_K) -> dict:
+    """
+    Query action from Milvus using vector similarity search
+    
+    Args:
+        angle: AngleToEnemy (degrees)
+        angle_score: AngleToEnemyScore [0, 1]
+        dist_score: DistanceToEnemyScore [0, 1]
+        near_score: NearBorderArenaScore [0, 1]
+        facing: FacingToArena [-1, 1]
+        top_k: Number of similar states to retrieve
+    
+    Returns:
+        {
+            "raw_output": "FWD 1.5, TR 0.8",
+            "action": {"Accelerate": 1.5, "TurnRight": 0.8},
+            "search_time_ms": 2.5,
+            "distance": 0.123,
+            "top_k_results": [...]  # Only if top_k > 1
+        }
+    """
+    # Encode state into vector
+    vec = encode_state(angle, angle_score, dist_score, near_score, facing)
+    
+    # Perform vector search
+    start = time.time()
+    
+    result = col.search(
+        data=[vec.tolist()],
+        anns_field="state_vec",
+        param={"nprobe": NPROBE},
+        limit=top_k,
+        output_fields=["action"],
+    )
+    
+    search_time = (time.time() - start) * 1000  # Convert to ms
+    
+    # Extract results
+    if len(result[0]) == 0:
+        raise ValueError("No similar states found in database")
+    
+    top_hit = result[0][0]
+    action_str = top_hit.entity.get("action")
+    distance = top_hit.distance
+    
+    # Parse action
+    parsed_actions = parse_action(action_str)
+    
+    response = {
+        "raw_output": action_str,
+        "action": parsed_actions,
+        "search_time_ms": round(search_time, 2),
+        "distance": round(distance, 4)
+    }
+    
+    # Include all results if top_k > 1
+    if top_k > 1:
+        response["top_k_results"] = [
+            {
+                "action": hit.entity.get("action"),
+                "distance": round(hit.distance, 4)
+            }
+            for hit in result[0]
+        ]
+    
+    return response
+
+def query_action_from_string(state_str: str, top_k: int = TOP_K) -> dict:
+    """
+    Query action from state string
+    
+    Args:
+        state_str: "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99"
+        top_k: Number of similar states to retrieve
+    
+    Returns:
+        Same as query_action()
+    """
+    # Parse state string
+    state_dict = parse_state_string(state_str)
+    
+    # Extract required fields
+    required_fields = [
+        "AngleToEnemy",
+        "AngleToEnemyScore",
+        "DistanceToEnemyScore",
+        "NearBorderArenaScore",
+        "FacingToArena"
+    ]
+    
+    missing_fields = [f for f in required_fields if f not in state_dict]
+    if missing_fields:
+        raise ValueError(f"Missing required fields: {missing_fields}")
+    
+    # Query action
+    return query_action(
+        angle=state_dict["AngleToEnemy"],
+        angle_score=state_dict["AngleToEnemyScore"],
+        dist_score=state_dict["DistanceToEnemyScore"],
+        near_score=state_dict["NearBorderArenaScore"],
+        facing=state_dict["FacingToArena"],
+        top_k=top_k
+    )
+
+# ==================== FastAPI Setup ====================
+app = FastAPI(
+    title="Sumobot Milvus Vector Search API",
+    description="Real-time Sumobot action retrieval using vector similarity search",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ==================== Request/Response Models ====================
+class QueryInput(BaseModel):
+    state: str
+    top_k: Optional[int] = 1
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "state": "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99",
+                "top_k": 1
+            }
+        }
+
+class QueryResponse(BaseModel):
+    raw_output: str
+    action: Dict[str, Optional[float]]
+    search_time_ms: float
+    distance: float
+    top_k_results: Optional[List[Dict]] = None
+
+class BatchQueryInput(BaseModel):
+    states: List[str]
+    top_k: Optional[int] = 1
+
+class HealthResponse(BaseModel):
+    status: str
+    milvus_host: str
+    collection: str
+    num_entities: int
+    platform: str
+
+# ==================== API Endpoints ====================
+
+@app.get("/", tags=["Info"])
+def root():
+    """Root endpoint with API information"""
+    return {
+        "message": "Sumobot Milvus Vector Search API",
+        "endpoints": {
+            "health": "/health",
+            "query": "/query (POST)",
+            "batch": "/batch (POST)",
+            "benchmark": "/benchmark (GET)",
+            "stats": "/stats (GET)"
+        }
+    }
+
+@app.get("/health", response_model=HealthResponse, tags=["Info"])
+def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "milvus_host": f"{MILVUS_HOST}:{MILVUS_PORT}",
+        "collection": COLLECTION_NAME,
+        "num_entities": col.num_entities,
+        "platform": f"{platform.system()} {platform.machine()}"
+    }
+
+@app.get("/stats", tags=["Info"])
+def collection_stats():
+    """Get collection statistics"""
+    return {
+        "collection": COLLECTION_NAME,
+        "num_entities": col.num_entities,
+        "schema": {
+            "fields": [
+                {
+                    "name": field.name,
+                    "type": str(field.dtype),
+                    "params": field.params
+                }
+                for field in col.schema.fields
+            ]
+        },
+        "indexes": [
+            {
+                "field": index.field_name,
+                "type": index.params.get("index_type"),
+                "metric": index.params.get("metric_type")
+            }
+            for index in col.indexes
+        ]
+    }
+
+@app.post("/query", response_model=QueryResponse, tags=["Search"])
+def query(input: QueryInput):
+    """
+    Get action prediction for a single game state
+    
+    Example:
+    ```json
+    {
+        "state": "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99",
+        "top_k": 1
+    }
+    ```
+    """
+    
+    try:
+        result = query_action_from_string(input.state, input.top_k)
+        return result
+    except Exception as e:
+        print(input.state)
+        print(f"Error query:\nInput: {input.state}\nDetail: {e.with_traceback()}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/batch", tags=["Search"])
+def batch_query(input: BatchQueryInput):
+    """
+    Get action predictions for multiple game states
+    
+    Example:
+    ```json
+    {
+        "states": [
+            "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99",
+            "AngleToEnemy=2.31, AngleToEnemyScore=0.45, DistanceToEnemyScore=0.92, NearBorderArenaScore=0.12, FacingToArena=0.67"
+        ],
+        "top_k": 1
+    }
+    ```
+    """
+    try:
+        results = []
+        total_time = 0
+        
+        for state in input.states:
+            result = query_action_from_string(state, input.top_k)
+            results.append(result)
+            total_time += result["search_time_ms"]
+        
+        return {
+            "results": results,
+            "total_search_time_ms": round(total_time, 2),
+            "avg_search_time_ms": round(total_time / len(results), 2)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/benchmark", tags=["Diagnostics"])
+def benchmark():
+    """
+    Benchmark vector search performance
+    
+    Runs 100 searches and returns statistics
+    """
+    test_state = "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99"
+    
+    print("\n🔥 Running benchmark...")
+    
+    # Warmup
+    query_action_from_string(test_state)
+    
+    # Benchmark
+    times = []
+    outputs = []
+    
+    num_runs = 100
+    for i in range(num_runs):
+        result = query_action_from_string(test_state)
+        times.append(result["search_time_ms"])
+        outputs.append(result["raw_output"])
+        
+        if (i + 1) % 20 == 0:
+            print(f"  Run {i+1}/{num_runs}: {result['search_time_ms']:.2f}ms")
+    
+    times_sorted = sorted(times)
+    
+    return {
+        "runs": num_runs,
+        "test_state": test_state,
+        "stats": {
+            "avg_latency_ms": round(sum(times) / len(times), 2),
+            "min_latency_ms": round(min(times), 2),
+            "max_latency_ms": round(max(times), 2),
+            "p50_latency_ms": round(times_sorted[len(times) // 2], 2),
+            "p95_latency_ms": round(times_sorted[int(len(times) * 0.95)], 2),
+            "p99_latency_ms": round(times_sorted[int(len(times) * 0.99)], 2),
+        },
+        "platform": {
+            "system": platform.system(),
+            "machine": platform.machine(),
+            "milvus": f"{MILVUS_HOST}:{MILVUS_PORT}",
+            "collection_size": col.num_entities
+        },
+        "sample_outputs": list(set(outputs[:10]))  # First 10 unique outputs
+    }
+
+# ==================== Main ====================
+if __name__ == "__main__":
+    port = 9999
+    print("\n🚀 Starting Sumobot Milvus API server...")
+    print(f"📡 Server will be available at: http://0.0.0.0:{port}")
+    print(f"📚 API docs: http://0.0.0.0:{port}/docs")
+    print(f"🔍 Health check: http://0.0.0.0:{port}/health")
+    print(f"📊 Stats: http://0.0.0.0:{port}/stats")
+    print("\n" + "="*70 + "\n")
+    
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )
+
+# ==================== Test Commands ====================
+f"""
+# Health check
+curl http://localhost:9999/health
+
+# Collection stats
+curl http://localhost:9999/stats
+
+# Single query
+curl -X POST http://localhost:9999/query \
+  -H "Content-Type: application/json" \
+  -d '{
+    "state": "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99"
+  }'
+
+# Query with top-k results
+curl -X POST http://localhost:9999/query \
+  -H "Content-Type: application/json" \
+  -d '{
+    "state": "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99",
+    "top_k": 3
+  }'
+
+# Batch query
+curl -X POST http://localhost:9999/batch \
+  -H "Content-Type: application/json" \
+  -d '{
+    "states": [
+      "AngleToEnemy=7.77, AngleToEnemyScore=0.99, DistanceToEnemyScore=0.76, NearBorderArenaScore=0.81, FacingToArena=-0.99",
+      "AngleToEnemy=2.31, AngleToEnemyScore=0.45, DistanceToEnemyScore=0.92, NearBorderArenaScore=0.12, FacingToArena=0.67"
+    ]
+  }'
+
+# Benchmark
+curl http://localhost:9999/benchmark
+
+# Interactive API docs
+# Open in browser: http://localhost:9999/docs
+"""

vdb/docker-compose.yml

@@ -0,0 +1,68 @@
+services:
+  etcd:
+    container_name: etcd
+    image: quay.io/coreos/etcd:v3.5.5
+    environment:
+      - ETCD_AUTO_COMPACTION_MODE=revision
+      - ETCD_AUTO_COMPACTION_RETENTION=1000
+      - ETCD_QUOTA_BACKEND_BYTES=4294967296
+      - ETCD_SNAPSHOT_COUNT=50000
+    command: >
+      etcd
+      -name etcd
+      -advertise-client-urls http://etcd:2379
+      -listen-client-urls http://0.0.0.0:2379
+      -listen-peer-urls http://0.0.0.0:2380
+      -initial-advertise-peer-urls http://etcd:2380
+      -initial-cluster etcd=http://etcd:2380
+      -data-dir /etcd
+    volumes:
+      - ./volumes/etcd:/etcd
+    networks:
+      - milvus
+
+  minio:
+    container_name: minio
+    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
+    environment:
+      - MINIO_ACCESS_KEY=minioadmin
+      - MINIO_SECRET_KEY=minioadmin
+    command: server /minio_data
+    volumes:
+      - ./volumes/minio:/minio_data
+    ports:
+      - "9000:9000"
+    networks:
+      - milvus
+
+  milvus-standalone:
+    container_name: milvus-standalone
+    image: milvusdb/milvus:v2.4.4
+    command: ["milvus", "run", "standalone"]
+    environment:
+      - ETCD_ENDPOINTS=etcd:2379
+      - MINIO_ADDRESS=minio:9000
+    ports:
+      - "19530:19530"
+      - "9091:9091"
+    depends_on:
+      - etcd
+      - minio
+    networks:
+      - milvus
+
+  attu:
+    container_name: attu
+    image: zilliz/attu:latest
+    environment:
+      - MILVUS_URL=milvus-standalone:19530
+    ports:
+      - "1233:3000"
+    depends_on:
+      - milvus-standalone
+    networks:
+      - milvus
+
+networks:
+  milvus:
+    driver: bridge

vdb/import_data.py

@@ -0,0 +1,40 @@
+import json
+import numpy as np
+from tqdm import tqdm
+from pymilvus import connections, Collection
+
+connections.connect("default", host="127.0.0.1", port="19530")
+col = Collection("sumobot_states")
+
+def encode_state(state_str):
+    # Parse numeric values from your formatted string
+    parts = dict(item.split('=') for item in state_str.strip('.').split(', '))
+    return np.array([
+        float(parts["AngleToEnemy"]) / 180.0,  # normalize angle
+        float(parts["AngleToEnemyScore"]),
+        float(parts["DistanceToEnemyScore"]),
+        float(parts["NearBorderArenaScore"]),
+        float(parts["FacingToArena"]),
+    ], dtype=np.float32)
+
+BATCH_SIZE = 5000
+DATA_PATH = "../dataset/temp.jsonl"
+
+batch_vecs, batch_actions = [], []
+with open(DATA_PATH, "r") as f:
+    for line in tqdm(f, desc="Reading dataset"):
+        item = json.loads(line)
+        vec = encode_state(item["state"])
+        batch_vecs.append(vec.tolist())
+        batch_actions.append(item["action"])
+
+        if len(batch_vecs) >= BATCH_SIZE:
+            col.insert([batch_vecs, batch_actions])
+            batch_vecs, batch_actions = [], []
+
+# Insert remainder
+if batch_vecs:
+    col.insert([batch_vecs, batch_actions])
+
+col.flush()
+print("✅ All data inserted & flushed to Milvus.")

vdb/query_actions.py

@@ -0,0 +1,25 @@
+import numpy as np
+from pymilvus import connections, Collection
+
+connections.connect("default", host="127.0.0.1", port="19530")
+col = Collection("sumobot_states")
+col.load()
+
+def encode_state(angle, angle_score, dist_score, near_score, facing):
+    return np.array([angle / 180.0, angle_score, dist_score, near_score, facing], dtype=np.float32)
+
+def query_action(angle, angle_score, dist_score, near_score, facing, top_k=1):
+    vec = encode_state(angle, angle_score, dist_score, near_score, facing)
+    result = col.search(
+        data=[vec],
+        anns_field="state_vec",
+        param={"nprobe": 16},
+        limit=top_k,
+        output_fields=["action"],
+    )
+    actions = [hit.entity.get("action") for hit in result[0]]
+    return actions[0] if top_k == 1 else actions
+
+# Example use
+action = query_action(63.55, 0.45, 0.81, 0.18, -0.48)
+print(f"🎮 Suggested Action: {action}")

vdb/setup_milvus.py

@@ -0,0 +1,58 @@
+from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection, utility
+
+# --------------------------
+# 1️⃣ Connect to Milvus
+# --------------------------
+connections.connect(alias="default", host="127.0.0.1", port="19530")
+print("✅ Connected to Milvus")
+
+# --------------------------
+# 2️⃣ Collection setup
+# --------------------------
+col_name = "sumobot_states"
+
+# Check if collection exists
+if col_name in utility.list_collections():
+    print(f"⚠️  Collection '{col_name}' already exists.")
+    col = Collection(col_name)
+    
+    # Print existing schema to debug
+    print(f"Existing schema fields: {[field.name for field in col.schema.fields]}")
+    
+    # Drop the old collection to recreate with correct schema
+    print(f"🗑️  Dropping existing collection to recreate...")
+    col.drop()
+    
+# Define fields
+fields = [
+    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
+    FieldSchema(name="state_vec", dtype=DataType.FLOAT_VECTOR, dim=5),  # 5 = vector dimension
+    FieldSchema(name="action", dtype=DataType.VARCHAR, max_length=64),
+]
+schema = CollectionSchema(fields, description="Sumobot state → action mapping")
+col = Collection(name=col_name, schema=schema)
+print(f"✅ Created collection '{col_name}'")
+
+# --------------------------
+# 3️⃣ Create vector index
+# --------------------------
+index_params = {
+    "index_type": "IVF_FLAT",    # or "AUTOINDEX" if you want Milvus to choose automatically
+    "metric_type": "L2",         # or "IP" (inner product)
+    "params": {"nlist": 128},    # depends on index type
+}
+
+# Create index
+col.create_index(field_name="state_vec", index_params=index_params)
+print("⚙️  Created index on 'state_vec'")
+
+# --------------------------
+# 4️⃣ Load collection into memory
+# --------------------------
+col.load()
+print("🚀 Collection loaded into memory")
+
+# --------------------------
+# Optional: release when done
+# --------------------------
+# col.release()