Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,182 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import torch
+import torch.nn as nn
+import pandas as pd
+import numpy as np
+import joblib
+import json
+from datetime import datetime
+from huggingface_hub import hf_hub_download
+
+st.set_page_config(page_title="FinTech Fraud Guard", page_icon="🛡️", layout="wide")
+
+st.markdown("""
+    <style>
+    .main { background-color: #0e1117; }
+    .stButton>button { width: 100%; border-radius: 20px; background: linear-gradient(45deg, #ff4b4b, #ff8f8f); color: white; border: none; }
+    .fraud-card { padding: 20px; border-radius: 15px; background-color: #1e2130; border-left: 5px solid #ff4b4b; margin-bottom: 20px; }
+    .legit-card { padding: 20px; border-radius: 15px; background-color: #1e2130; border-left: 5px solid #00ffcc; margin-bottom: 20px; }
+    </style>
+    """, unsafe_allow_html=True)
+
+class MoEFraudModel(nn.Module):
+    def __init__(self, cat_dims, num_cols_map, embed_dim=8):
+        super(MoEFraudModel, self).__init__()
+        self.embeddings = nn.ModuleDict({
+            col: nn.Embedding(num_classes, embed_dim) 
+            for col, num_classes in cat_dims.items()
+        })
+        self.cat_cols = list(cat_dims.keys())
+        self.num_cols = list(num_cols_map.keys())
+        self.cat_idx = {name: i for i, name in enumerate(self.cat_cols)}
+        self.num_idx = {name: i for i, name in enumerate(self.num_cols)}
+        
+        total_input_dim = (len(self.cat_cols) * embed_dim) + len(self.num_cols)
+        self.gating_network = nn.Sequential(
+            nn.Linear(total_input_dim, 64), nn.BatchNorm1d(64), nn.ReLU(),
+            nn.Dropout(0.2), nn.Linear(64, 4), nn.Softmax(dim=1)
+        )
+        
+        self.e1_cols_num = ['amt', 'hour', 'day_of_week', 'is_weekend', 'unix_time']
+        self.e1_cols_cat = ['category']
+        self.e2_cols_num = ['city_pop', 'age', 'time_diff_cc', 'cc_avg_amt_last_5', 'cc_std_amt_last_5', 'cc_max_amt_last_5']
+        self.e2_cols_cat = ['cc_num', 'gender', 'job', 'city', 'state', 'zip']
+        self.e3_cols_num = ['merchant_fraud_rate', 'merchant_txn_count']
+        self.e3_cols_cat = ['merchant', 'category']
+        self.e4_cols_num = ['lat', 'long', 'merch_lat', 'merch_long', 'distance_customer_merchant', 'state_mismatch_flag']
+        self.e4_cols_cat = [] 
+
+        self.expert1 = self._make_expert(self._get_dim(self.e1_cols_cat, self.e1_cols_num, embed_dim))
+        self.expert2 = self._make_expert(self._get_dim(self.e2_cols_cat, self.e2_cols_num, embed_dim))
+        self.expert3 = self._make_expert(self._get_dim(self.e3_cols_cat, self.e3_cols_num, embed_dim))
+        self.expert4 = self._make_expert(self._get_dim(self.e4_cols_cat, self.e4_cols_num, embed_dim))
+
+        self.classifier = nn.Sequential(nn.Linear(32, 16), nn.ReLU(), nn.Dropout(0.2), nn.Linear(16, 1))
+
+    def _get_dim(self, cats, nums, embed_dim): return len(nums) + (len(cats) * embed_dim)
+    def _make_expert(self, input_dim):
+        return nn.Sequential(nn.Linear(input_dim, 128), nn.BatchNorm1d(128), nn.ReLU(), nn.Dropout(0.2), nn.Linear(128, 32), nn.ReLU())
+
+    def get_features(self, cat_input, num_input, req_cat, req_num):
+        parts = []
+        if req_num:
+            indices = [self.num_idx[c] for c in req_num]
+            parts.append(num_input[:, indices])
+        if req_cat:
+            for c in req_cat:
+                idx = self.cat_idx[c]
+                emb = self.embeddings[c](cat_input[:, idx])
+                parts.append(emb)
+        return torch.cat(parts, dim=1)
+
+    def forward(self, cat_input, num_input):
+        all_embs = [self.embeddings[c](cat_input[:, i]) for i, c in enumerate(self.cat_cols)]
+        global_features = torch.cat([torch.cat(all_embs, dim=1), num_input], dim=1)
+        weights = self.gating_network(global_features)
+        h1 = self.expert1(self.get_features(cat_input, num_input, self.e1_cols_cat, self.e1_cols_num))
+        h2 = self.expert2(self.get_features(cat_input, num_input, self.e2_cols_cat, self.e2_cols_num))
+        h3 = self.expert3(self.get_features(cat_input, num_input, self.e3_cols_cat, self.e3_cols_num))
+        h4 = self.expert4(self.get_features(cat_input, num_input, self.e4_cols_cat, self.e4_cols_num))
+        h_final = (weights[:, 0:1]*h1 + weights[:, 1:2]*h2 + weights[:, 2:3]*h3 + weights[:, 3:4]*h4)
+        return self.classifier(h_final)
+
+REPO_ID = "rocky250/FinTech"
+
+@st.cache_resource
+def load_assets():
+    weights_path = hf_hub_download(repo_id=REPO_ID, filename="proposed_moe_model.pth")
+    config_path = hf_hub_download(repo_id=REPO_ID, filename="config.json")
+    encoders_path = hf_hub_download(repo_id=REPO_ID, filename="label_encoders.joblib")
+    scaler_path = hf_hub_download(repo_id=REPO_ID, filename="scaler.joblib")
+    
+    with open(config_path, 'r') as f:
+        config = json.load(f)
+    
+    model = MoEFraudModel(config['cat_dims'], config['num_cols_map'], config['embed_dim'])
+    model.load_state_dict(torch.load(weights_path, map_location=torch.device('cpu')))
+    model.eval()
+    
+    return model, joblib.load(encoders_path), joblib.load(scaler_path), config
+
+model, encoders, scaler, config = load_assets()
+
+st.title("FinTech Fraud Analysis")
+st.markdown("### Proposed Mixture-of-Experts (MoE) Architecture")
+
+with st.form("transaction_form"):
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.subheader("Customer Info")
+        first = st.text_input("First Name", "Jeff")
+        last = st.text_input("Last Name", "Elliott")
+        gender = st.selectbox("Gender", ["M", "F"])
+        cc_num = st.text_input("Credit Card Number", "2.29116E+15")
+        
+    with col2:
+        st.subheader("Transaction Info")
+        trans_dt = st.text_input("Date & Time (DD-MM-YYYY HH:MM)", "21-06-2020 12:14")
+        merchant = st.text_input("Merchant", "fraud_Kirlin and Sons")
+        category = st.text_input("Category", "personal_care")
+        amt = st.number_input("Amount ($)", value=2.86)
+        
+    with col3:
+        st.subheader("Location Info")
+        street = st.text_input("Street", "351 Darlene Green")
+        city = st.text_input("City", "Birmingham")
+        state = st.text_input("State", "AL")
+        zip_code = st.text_input("Zip Code", "35201")
+
+    submit = st.form_submit_button("ANALYZE TRANSACTION")
+
+if submit:
+    try:
+        dt_obj = datetime.strptime(trans_dt, "%d-%m-%Y %H:%M")
+        
+        Build numerical feature vector (Must match the 19 features in training)
+        Order: ['amt', 'hour', 'day_of_week', 'is_weekend', 'unix_time', 'city_pop', 'age', 
+                'time_diff_cc', 'cc_avg_amt_last_5', 'cc_std_amt_last_5', 'cc_max_amt_last_5', 
+                'merchant_fraud_rate', 'merchant_txn_count', 'lat', 'long', 'merch_lat', 
+                'merch_long', 'distance_customer_merchant', 'state_mismatch_flag']
+        
+        num_feats = [
+            amt, dt_obj.hour, dt_obj.weekday(), 1 if dt_obj.weekday() >= 5 else 0, dt_obj.timestamp(),
+            50000, 35, 3600, 50.0, 10.0, 100.0, 0.02, 1000, 33.5, -86.8, 33.6, -86.9, 15.5, 0
+        ]
+        
+        cat_feats = [category, cc_num, gender, "Job", city, state, zip_code, merchant]
+
+        num_input = scaler.transform([num_feats])
+        
+        cat_encoded = []
+        for i, col in enumerate(config['cat_dims'].keys()):
+            val = str(cat_feats[i])
+            if val in encoders[col].classes_:
+                cat_encoded.append(encoders[col].transform([val])[0])
+            else:
+                cat_encoded.append(0) 
+        
+        with torch.no_grad():
+            cat_t = torch.tensor([cat_encoded], dtype=torch.long)
+            num_t = torch.tensor(num_input, dtype=torch.float32)
+            logits = model(cat_t, num_t)
+            prob = torch.sigmoid(logits).item()
+
+        st.divider()
+        if prob > 0.5:
+            st.markdown(f"""<div class="fraud-card">
+                <h2>High Risk Detected!</h2>
+                <p>Confidence: {prob*100:.2f}%</p>
+                <p>This transaction matches fraud patterns identified by the Expert Gating Network.</p>
+                </div>""", unsafe_allow_html=True)
+        else:
+            st.markdown(f"""<div class="legit-card">
+                <h2>Transaction Safe</h2>
+                <p>Confidence: {(1-prob)*100:.2f}%</p>
+                <p>Analysis shows this is a legitimate transaction based on customer behavior Experts.</p>
+                </div>""", unsafe_allow_html=True)
+                
+    except Exception as e:
+        st.error(f"Error in processing: {e}")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+st.sidebar.info("This model uses a **MoE Architecture** with 4 specialized experts for Financial Fraud Detection.")