merge frontend and updated LLM

Author: aaaimee000

backend/LLM/router.py

@@ -1,50 +1,5 @@
 # llm/router.py
 import json
-<<<<<<< HEAD
-from typing import Any, Dict
-
-from .client import client, MODEL
-from ..models import Intent
-
-# Describe allowable actions & fields (for the prompt)
-ACTION_ENUM = ["upload_data", "find_anomalies", "get_output", "rerun", "reset", "help"]
-
-SYSTEM_PROMPT = f"""
-You are an intent parser for the ADaS app. Always return a single JSON object
-with keys "action" and "params". The "action" must be one of: {ACTION_ENUM}.
-The "params" is an object of optional keys such as:
-  - top_n: integer
-  - num_features: integer
-  - time_range: string like "past_day" | "past_week" | "past_month"
-  - target_ip: string ip address
-  - explanation: "none" | "simple" | "verbose"
-  - sort_by: "ip" | "time" | "quantity" | "score"
-  - uid_column: string
-Never include commentary, code fences, or extra text—only valid JSON.
-Infer only what is stated or strongly implied by the user text.
-If uncertain about a field, omit it from "params" rather than guessing.
-"""
-
-def _validate_to_intent(raw: Dict[str, Any]) -> Intent:
-    """
-    Convert a raw dict (from model) into our Pydantic Intent model.
-    This enforces allowed enum values and types.
-    """
-    # Minimal normalization (optional): lowercase action if present
-    if isinstance(raw, dict) and "action" in raw and isinstance(raw["action"], str):
-        raw["action"] = raw["action"].strip().lower()
-
-    # Pydantic validation (raises if invalid)
-    return Intent.model_validate(raw)
-
-
-def resolve_intent(user_text: str) -> Intent:
-    """
-    Parse natural language into a structured {action, params} using Chat Completions JSON mode.
-    Falls back to plain text -> JSON parse if JSON mode isn't available in the SDK.
-    """
-    # Preferred path: JSON mode (chat.completions with response_format={"type":"json_object"})
-=======
 from json import JSONDecodeError
 from typing import Any, Dict
 from datetime import datetime, timedelta, timezone
@@ -259,24 +214,13 @@ def resolve_intent(user_text: str) -> Intent:
     Parse natural language into {action, params} via OpenAI JSON mode,
     then normalize and validate.
     """
->>>>>>> frontend
     try:
         resp = client.chat.completions.create(
             model=MODEL,
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": user_text},
             ],
-<<<<<<< HEAD
-            response_format={"type": "json_object"},  # strict JSON response
-        )
-        content = resp.choices[0].message.content or "{}"
-        data = json.loads(content)
-        return _validate_to_intent(data)
-
-    except TypeError:
-        # Some environments may not support response_format; fallback to plain text then json.loads
-=======
             response_format={"type": "json_object"},
         )
         content = resp.choices[0].message.content or "{}"
@@ -285,37 +229,21 @@ def resolve_intent(user_text: str) -> Intent:
 
     except TypeError:
         # Fallback if response_format is not supported
->>>>>>> frontend
         resp = client.chat.completions.create(
             model=MODEL,
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
                 {"role": "user", "content": user_text},
-<<<<<<< HEAD
-            ]
-        )
-        content = resp.choices[0].message.content or "{}"
-
-        # Try to locate JSON in the reply (in case the model added extra text)
-        # Simple heuristic: find the first '{' and last '}'.
-=======
             ],
         )
         content = resp.choices[0].message.content or "{}"
->>>>>>> frontend
         start = content.find("{")
         end = content.rfind("}")
         if start != -1 and end != -1 and end > start:
             payload = content[start : end + 1]
         else:
             payload = "{}"
-<<<<<<< HEAD
-
-        data = json.loads(payload)
-        return _validate_to_intent(data)
-=======
         data = json.loads(payload)
         return _postprocess_and_validate(data)
->>>>>>> frontend
 
 

backend/api/interpret.py

@@ -6,11 +6,7 @@
 import numpy as np
 from sklearn.decomposition import PCA
 from sklearn.preprocessing import StandardScaler, LabelEncoder
-<<<<<<< HEAD
-from reinforcementLearning import run_rl
-=======
 from backend.reinforcementLearning import run_rl
->>>>>>> frontend
 
 
 backend_data = {"df": None,
@@ -58,8 +54,6 @@ def clean_data(df):
 
 ###### FEATURE SELECTION & FIND ANOMALIES #####
 
-<<<<<<< HEAD
-=======
 #############TESTING PURPOSES ONLY START #############
 
 def find_anomalies(query, uid, num_feat, start=None, end=None, source_ip=None):
@@ -94,96 +88,11 @@ def find_anomalies(query, uid, num_feat, start=None, end=None, source_ip=None):
     return mock_table
 
 #############TESTING PURPOSES ONLY END #############
->>>>>>> frontend
 '''
 Summary: Takes the user query, performs feature selection and RL. Updates all global data.
 Input:
 Output:
 '''
-<<<<<<< HEAD
-def find_anomalies(query, uid, num_feat):
-
-    ## FEATURE SELECTION
-    main_identifiers = [uid] # TODO: could later add option for additional headings to ignore, otherwise switch to just UID
-    backend_data["uid"] = uid
-    df = backend_data["df"]
-    num_entries = df.shape[0]
-    drop = []
-    for i in df:
-        if df[i].dtype == 'O' and i not in main_identifiers: # qualitative
-            qual_to_quant(df, i)
-            if df[i].nunique() > (num_entries / 2) or df[i].nunique() == 1: # if more than 1/2 of data points have a unique label OR all have same label, drop the column. can change this!
-                drop.append(i)
-    # print(drop)
-    cleaned_df = df.drop(columns = drop)
-    qual_to_quant(cleaned_df, main_identifiers[0])
-    backend_data["df"] = cleaned_df
-    # print("Final Columns:", str(cleaned_df.shape[1]))
-    # print(cleaned_df.head())
-
-    pca, features = get_features(cleaned_df, num_feat, main_identifiers)
-    backend_data["features"] = features
-
-    ## REINFORCEMENT LEARNING
-    anomalies, cluster_sizes, final_features = run_rl(backend_data) #TODO: others for output data
-    backend_data["anomalies"] = anomalies
-    return anomalies
-
-'''Converts the qualitative column col in df to quantitative values'''
-def qual_to_quant(df, col):
-    le = LabelEncoder()
-    df[col] = le.fit_transform(df[col])
-
-"Returns an array with the indexes of the top n values in arr"
-def get_top_n_idx(n, arr):
-  arr = np.abs(arr)
-  top = np.argpartition(arr, -n)[-n:]
-  return top
-
-'''
-Returns a numpy array of the selected features from data using PCA.
-
-PCA: develops unspecified number of components to represent data
-Feature Selection: getting the top_n features that have the highest weighted
-importance across all components 
-'''
-def get_features(data, top_n, main_identifiers):
-  copy = data.copy(deep=True)  # Make a copy of the original data to avoid modifying it
-  feat_options = copy.drop(columns=main_identifiers).copy(deep=True)  # Drop columns like unique IDs that shouldn't be scaled
-
-  # Standardize the data
-  scaler = StandardScaler()
-  scaler.fit(feat_options)
-  scaled_data = scaler.transform(feat_options)
-
-  pca = PCA(n_components=0.95) # should represent at least 95% of overall trends in data
-  pca.fit(scaled_data)
-
-  ### USE ABSOLUTE VALUE OF LOADINGS ONLY FOR FEATURE IMPORTANCE 
-  loadings = np.abs(pca.components_)  # Get importance for each feature in each component
-  # feature_importance = np.sum(loadings, axis=0)  # Sum the absolute loadings for each feature across all components
-
-  ### USE WEIGHTED LOADINGS BY EXPLAINED VARIANCE FOR FEATURE IMPORTANCE
-  weighted_loadings = np.abs(pca.components_) * pca.explained_variance_ratio_.reshape(-1, 1)
-  feature_importance = np.sum(weighted_loadings, axis=0)
-
-
-  # Get the indexes of the top n most important features based on summed importance
-  top = get_top_n_idx(top_n, feature_importance)
-
-  # Get the feature names for the most important features
-  most_important_names = feat_options.columns[top]
-
-  # Print the selected important features
-  print("Most Important Features:", most_important_names.tolist())
-
-  # Return the unique top features
-  unique_feats = np.unique(most_important_names)
-  print("Unique Features:", unique_feats.tolist())
-
-  # Return the selected unique features
-  return pca, unique_feats
-=======
 # def find_anomalies(query, uid, num_feat, start=None, end=None, source_ip=None):
 
 #     ## FEATURE SELECTION
@@ -266,7 +175,6 @@ def get_features(data, top_n, main_identifiers):
 
 #   # Return the selected unique features
 #   return pca, unique_feats
->>>>>>> frontend
 
 
 ##### GET OUTPUT #####
@@ -277,9 +185,6 @@ def get_features(data, top_n, main_identifiers):
 Output:
 '''
 def get_output():
-<<<<<<< HEAD
-    return("Returning results")
-=======
     ######## JUST FOR TESTING PURPOSES ########
     return {
         "ok": True,
@@ -288,4 +193,3 @@ def get_output():
             "summary": "Returning test results"
         }
     }
->>>>>>> frontend

backend/backendInterface.py

@@ -1,19 +1,9 @@
 from fastapi import FastAPI, File, UploadFile, HTTPException
-<<<<<<< HEAD
-from backendInterface import add_data, find_anomalies, get_output
-from fastapi.middleware.cors import CORSMiddleware
-
-# Mount routers
-from .api.intent import router as intent_router
-from .api.interpret import router as interpret_router
-
-=======
 from backend.backendInterface import add_data, find_anomalies, get_output
 from fastapi.middleware.cors import CORSMiddleware
 
 # Mount routers
 from backend.api.intent import router as intent_router
->>>>>>> frontend
 app = FastAPI()
 
 # Allow frontend to call API from a different origin/port
@@ -26,11 +16,7 @@
 
 # LLM routes
 app.include_router(intent_router)
-<<<<<<< HEAD
-app.include_router(interpret_router)
-=======
 # app.include_router(interpret_router)
->>>>>>> frontend
 
 # Original routes
 @app.post("/add_data/")