feat: complete demo

README.md

@@ -4,32 +4,34 @@ This project implements a federated learning framework combined with a Retrieval
 
 ## Features
 
-- Federated Learning using TensorFlow Federated
+- Federated Learning using TensorFlow
 - Privacy-preserving data generation using VAE/GAN
 - RAG integration for enhanced data quality
 - Secure Multi-Party Computation (SMPC)
 - Differential Privacy implementation
 - Kubernetes-based deployment
 - Comprehensive monitoring and logging
+- **NEW: Interactive Web Demo** - Try it out without setup!
 
-## Installation
-
-```bash
-pip install -r requirements.txt
-```
-
-## Usage
+## Quick Demo (No Installation Required)
 
+🚀 **Live Demo**: [Hugging Face Spaces](https://huggingface.co/spaces/ArchCoder/federated-credit-scoring)
 
-## Project Structure
-
+The web demo allows you to:
+- Enter customer features and get credit score predictions
+- See how federated learning works
+- Understand privacy-preserving ML concepts
 
-## License
-
-MIT
+## Installation
 
-## Contributing
+```bash
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
 
+# Install dependencies
+pip install -r requirements.txt
+```
 
 ## Federated Credit Scoring Demo (with Web App)
 
@@ -65,7 +67,37 @@ streamlit run webapp/streamlit_app.py
 - Enter 32 features (dummy values are fine for demo)
 - Click "Predict Credit Score" to get a prediction from the federated model
 - View training progress in the app
+- Toggle between Demo Mode (no server required) and Real Mode (connects to server)
 
 *For best results, keep the server and at least two clients running in parallel.*
 
+## Project Structure
+
+```
+FinFedRAG-Financial-Federated-RAG/
+├── src/
+│   ├── api/           # REST API for server and client communication
+│   ├── client/        # Federated learning client implementation
+│   ├── server/        # Federated learning server and coordinator
+│   ├── rag/           # Retrieval-Augmented Generation components
+│   ├── models/        # VAE/GAN models for data generation
+│   └── utils/         # Privacy, metrics, and utility functions
+├── webapp/            # Streamlit web application
+├── config/            # Configuration files
+├── tests/             # Unit and integration tests
+├── docker/            # Docker configurations
+├── kubernetes/        # Kubernetes deployment files
+└── app.py             # Root app.py for Hugging Face Spaces deployment
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Please read our contributing guidelines before submitting pull requests.
+
 ---
+
+**Demo URL**: https://huggingface.co/spaces/ArchCoder/federated-credit-scoring

app.py

@@ -0,0 +1,119 @@
+import streamlit as st
+import requests
+import numpy as np
+import time
+
+st.set_page_config(page_title="Federated Credit Scoring Demo", layout="centered")
+st.title("Federated Credit Scoring Demo (Federated Learning)")
+
+# Sidebar configuration
+st.sidebar.header("Configuration")
+SERVER_URL = st.sidebar.text_input("Server URL", value="http://localhost:8080")
+DEMO_MODE = st.sidebar.checkbox("Demo Mode (No Server Required)", value=True)
+
+st.markdown("""
+This demo shows how multiple banks can collaboratively train a credit scoring model using federated learning, without sharing raw data.
+Enter customer features below to get a credit score prediction from the federated model.
+""")
+
+# --- Feature Input Form ---
+st.header("Enter Customer Features")
+with st.form("feature_form"):
+    features = []
+    cols = st.columns(4)
+    for i in range(32):
+        with cols[i % 4]:
+            val = st.number_input(f"Feature {i+1}", value=0.0, format="%.4f", key=f"f_{i}")
+            features.append(val)
+    submitted = st.form_submit_button("Predict Credit Score")
+
+# --- Prediction ---
+if submitted:
+    if DEMO_MODE:
+        # Demo mode - simulate prediction
+        with st.spinner("Processing prediction..."):
+            time.sleep(1)  # Simulate processing time
+        
+        # Simple demo prediction based on feature values
+        demo_prediction = sum(features) / len(features) * 100 + 500  # Scale to credit score range
+        st.success(f"Demo Prediction: Credit Score = {demo_prediction:.2f}")
+        st.info("💡 This is a demo prediction. In a real federated system, this would come from the trained model.")
+        
+        # Show what would happen in real mode
+        st.markdown("---")
+        st.markdown("**What happens in real federated learning:**")
+        st.markdown("1. Your features are sent to the federated server")
+        st.markdown("2. Server uses the global model (trained by multiple banks)")
+        st.markdown("3. Prediction is returned without exposing any bank's data")
+        
+    else:
+        # Real mode - connect to server
+        try:
+            with st.spinner("Connecting to federated server..."):
+                resp = requests.post(f"{SERVER_URL}/predict", json={"features": features}, timeout=10)
+            
+            if resp.status_code == 200:
+                prediction = resp.json().get("prediction")
+                st.success(f"Predicted Credit Score: {prediction:.2f}")
+            else:
+                st.error(f"Prediction failed: {resp.json().get('error', 'Unknown error')}")
+        except Exception as e:
+            st.error(f"Error connecting to server: {e}")
+            st.info("💡 Try enabling Demo Mode to see the interface without a server.")
+
+# --- Training Progress ---
+st.header("Federated Training Progress")
+
+if DEMO_MODE:
+    # Demo training progress
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Current Round", "3/10")
+    with col2:
+        st.metric("Active Clients", "3")
+    with col3:
+        st.metric("Model Accuracy", "85.2%")
+    with col4:
+        st.metric("Training Status", "Active")
+    
+    st.info("💡 Demo mode showing simulated training progress. In real federated learning, multiple banks would be training collaboratively.")
+    
+else:
+    # Real training progress
+    try:
+        status = requests.get(f"{SERVER_URL}/training_status", timeout=5)
+        if status.status_code == 200:
+            data = status.json()
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Current Round", f"{data.get('current_round', 0)}/{data.get('total_rounds', 10)}")
+            with col2:
+                st.metric("Active Clients", data.get('active_clients', 0))
+            with col3:
+                st.metric("Clients Ready", data.get('clients_ready', 0))
+            with col4:
+                st.metric("Training Status", "Active" if data.get('training_active', False) else "Inactive")
+        else:
+            st.warning("Could not fetch training status.")
+    except Exception as e:
+        st.warning(f"Could not connect to server for training status: {e}")
+
+# --- How it works ---
+st.header("How Federated Learning Works")
+st.markdown("""
+**Traditional ML:** All banks send their data to a central server → Privacy risk ❌
+
+**Federated Learning:** 
+1. Each bank keeps their data locally ✅
+2. Banks train models on their own data ✅  
+3. Only model updates (not data) are shared ✅
+4. Server aggregates updates to create global model ✅
+5. Global model is distributed back to all banks ✅
+
+**Result:** Collaborative learning without data sharing! 🎯
+""")
+
+st.markdown("---")
+st.markdown("""
+*This is a demonstration of federated learning concepts. For full functionality, run the federated server and clients locally.*
+""") 

config/client_config.yaml

@@ -23,6 +23,7 @@ client:
   training:
     local_epochs: 3
     learning_rate: 0.001
+    batch_size: 32
     
   # Privacy configuration
   privacy:

config/server_config.yaml

@@ -1,26 +1,25 @@
 # server_config.yaml configuration
 
-server:
-  # API server configuration
-  api:
-    host: "0.0.0.0"
-    port: 8080
-    debug: false
-    
-  # Federated learning configuration
-  federated:
-    min_clients: 2
-    rounds: 10
-    sample_fraction: 0.8
-    
-  # Aggregation configuration
-  aggregation:
-    method: "fedavg"
-    weighted: true
-    
-  # Monitoring configuration
-  monitoring:
-    log_level: "INFO"
+# API server configuration
+api:
+  host: "0.0.0.0"
+  port: 8080
+  debug: false
+  
+# Federated learning configuration
+federated:
+  min_clients: 2
+  rounds: 10
+  sample_fraction: 0.8
+  
+# Aggregation configuration
+aggregation:
+  method: "fedavg"
+  weighted: true
+  
+# Monitoring configuration
+monitoring:
+  log_level: "INFO"
 
 # Model configuration
 model:

requirements.txt

@@ -1,13 +1,28 @@
-# Core ML frameworks
-tensorflow
-tensorflow-federated
-torch
-transformers
+# Core ML and Deep Learning
+tensorflow>=2.8.0
+numpy>=1.21.0
+pandas>=1.3.0
+scikit-learn>=1.0.0
 
-# Data processing
-pandas
-numpy
-scikit-learn
+# Web Framework and API
+flask>=2.0.0
+requests>=2.25.0
+streamlit
+
+# Configuration and utilities
+pyyaml>=6.0
+pathlib2>=2.3.0
+
+# Development and testing
+pytest>=6.0.0
+pytest-cov>=2.0.0
+
+# Logging and monitoring
+python-json-logger>=2.0.0
+
+# Optional: For advanced features
+# tensorflow-federated>=0.20.0  # Uncomment if using TFF
+# torch>=1.10.0  # Uncomment if using PyTorch
 
 # RAG components
 elasticsearch
@@ -18,19 +33,8 @@ tensorflow-privacy
 pysyft
 
 # API and web
-flask
 fastapi
 uvicorn
-requests
-streamlit
-
-# Configuration and utilities
-pyyaml
-# Testing and development
-pytest
-black
-flake8
-isort
 
 # Documentation
 sphinx

webapp/streamlit_app.py

@@ -1,11 +1,15 @@
 import streamlit as st
 import requests
 import numpy as np
+import time
 
 st.set_page_config(page_title="Federated Credit Scoring Demo", layout="centered")
 st.title("Federated Credit Scoring Demo (Federated Learning)")
 
+# Sidebar configuration
+st.sidebar.header("Configuration")
 SERVER_URL = st.sidebar.text_input("Server URL", value="http://localhost:8080")
+DEMO_MODE = st.sidebar.checkbox("Demo Mode (No Server Required)", value=True)
 
 st.markdown("""
 This demo shows how multiple banks can collaboratively train a credit scoring model using federated learning, without sharing raw data.
@@ -24,34 +28,92 @@ with st.form("feature_form"):
     submitted = st.form_submit_button("Predict Credit Score")
 
 # --- Prediction ---
-prediction = None
 if submitted:
+    if DEMO_MODE:
+        # Demo mode - simulate prediction
+        with st.spinner("Processing prediction..."):
+            time.sleep(1)  # Simulate processing time
+        
+        # Simple demo prediction based on feature values
+        demo_prediction = sum(features) / len(features) * 100 + 500  # Scale to credit score range
+        st.success(f"Demo Prediction: Credit Score = {demo_prediction:.2f}")
+        st.info("💡 This is a demo prediction. In a real federated system, this would come from the trained model.")
+        
+        # Show what would happen in real mode
+        st.markdown("---")
+        st.markdown("**What happens in real federated learning:**")
+        st.markdown("1. Your features are sent to the federated server")
+        st.markdown("2. Server uses the global model (trained by multiple banks)")
+        st.markdown("3. Prediction is returned without exposing any bank's data")
+        
+    else:
+        # Real mode - connect to server
+        try:
+            with st.spinner("Connecting to federated server..."):
+                resp = requests.post(f"{SERVER_URL}/predict", json={"features": features}, timeout=10)
+            
+            if resp.status_code == 200:
+                prediction = resp.json().get("prediction")
+                st.success(f"Predicted Credit Score: {prediction:.2f}")
+            else:
+                st.error(f"Prediction failed: {resp.json().get('error', 'Unknown error')}")
+        except Exception as e:
+            st.error(f"Error connecting to server: {e}")
+            st.info("💡 Try enabling Demo Mode to see the interface without a server.")
+
+# --- Training Progress ---
+st.header("Federated Training Progress")
+
+if DEMO_MODE:
+    # Demo training progress
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Current Round", "3/10")
+    with col2:
+        st.metric("Active Clients", "3")
+    with col3:
+        st.metric("Model Accuracy", "85.2%")
+    with col4:
+        st.metric("Training Status", "Active")
+    
+    st.info("💡 Demo mode showing simulated training progress. In real federated learning, multiple banks would be training collaboratively.")
+    
+else:
+    # Real training progress
     try:
-        resp = requests.post(f"{SERVER_URL}/predict", json={"features": features}, timeout=10)
-        if resp.status_code == 200:
-            prediction = resp.json().get("prediction")
-            st.success(f"Predicted Credit Score: {prediction:.2f}")
+        status = requests.get(f"{SERVER_URL}/training_status", timeout=5)
+        if status.status_code == 200:
+            data = status.json()
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Current Round", f"{data.get('current_round', 0)}/{data.get('total_rounds', 10)}")
+            with col2:
+                st.metric("Active Clients", data.get('active_clients', 0))
+            with col3:
+                st.metric("Clients Ready", data.get('clients_ready', 0))
+            with col4:
+                st.metric("Training Status", "Active" if data.get('training_active', False) else "Inactive")
         else:
-            st.error(f"Prediction failed: {resp.json().get('error', 'Unknown error')}")
+            st.warning("Could not fetch training status.")
     except Exception as e:
-        st.error(f"Error connecting to server: {e}")
+        st.warning(f"Could not connect to server for training status: {e}")
 
-# --- Training Progress ---
-st.header("Federated Training Progress")
-try:
-    status = requests.get(f"{SERVER_URL}/training_status", timeout=5)
-    if status.status_code == 200:
-        data = status.json()
-        st.write(f"Current Round: {data.get('current_round', 0)} / {data.get('total_rounds', 10)}")
-        st.write(f"Active Clients: {data.get('active_clients', 0)}")
-        st.write(f"Clients Ready: {data.get('clients_ready', 0)}")
-        st.write(f"Training Active: {data.get('training_active', False)}")
-    else:
-        st.warning("Could not fetch training status.")
-except Exception as e:
-    st.warning(f"Could not connect to server for training status: {e}")
+# --- How it works ---
+st.header("How Federated Learning Works")
+st.markdown("""
+**Traditional ML:** All banks send their data to a central server → Privacy risk ❌
+
+**Federated Learning:** 
+1. Each bank keeps their data locally ✅
+2. Banks train models on their own data ✅  
+3. Only model updates (not data) are shared ✅
+4. Server aggregates updates to create global model ✅
+5. Global model is distributed back to all banks ✅
+
+**Result:** Collaborative learning without data sharing! 🎯
+""")
 
 st.markdown("---")
 st.markdown("""
-*This is a demo. All data is synthetic. For best results, run the federated server and at least two clients in parallel.*
+*This is a demonstration of federated learning concepts. For full functionality, run the federated server and clients locally.*
 """)