feat: add streamlit app

README.md

@@ -30,3 +30,42 @@ MIT
 
 ## Contributing
 
+
+## Federated Credit Scoring Demo (with Web App)
+
+This project includes a demo where multiple banks (clients) collaboratively train a credit scoring model using federated learning. A Streamlit web app allows you to enter customer features and get a credit score prediction from the federated model.
+
+### Quick Start
+
+1. **Install dependencies**
+
+```bash
+pip install -r requirements.txt
+```
+
+2. **Start the Federated Server**
+
+```bash
+python -m src.main --mode server --config config/server_config.yaml
+```
+
+3. **Start at least two Clients (in separate terminals)**
+
+```bash
+python -m src.main --mode client --config config/client_config.yaml
+```
+
+4. **Run the Web App**
+
+```bash
+streamlit run webapp/streamlit_app.py
+```
+
+5. **Use the Web App**
+- 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
+
+*For best results, keep the server and at least two clients running in parallel.*
+
+---

requirements.txt

@@ -1,12 +1,12 @@
 # Core ML frameworks
-tensorflow>=2.6.0
+tensorflow
 tensorflow-federated
-torch>=1.9.0
+torch
 transformers
 
 # Data processing
-pandas>=1.3.0
-numpy>=1.19.0
+pandas
+numpy
 scikit-learn
 
 # RAG components
@@ -18,14 +18,14 @@ tensorflow-privacy
 pysyft
 
 # API and web
-flask>=2.0.0
+flask
 fastapi
 uvicorn
-requests>=2.25.0
+requests
+streamlit
 
 # Configuration and utilities
-pyyaml>=5.4.0
-
+pyyaml
 # Testing and development
 pytest
 black
@@ -37,4 +37,4 @@ sphinx
 sphinx-rtd-theme
 
 # Additional requirements
-pyyaml>=5.4.1
+pyyaml

src/api/server.py

@@ -149,6 +149,42 @@ class FederatedAPI:
                 logger.error(f"Error processing RAG query: {str(e)}")
                 return jsonify({'error': str(e)}), 500
     
+        @self.app.route('/predict', methods=['POST'])
+        def predict():
+            """Predict using the current global model."""
+            try:
+                data = request.get_json()
+                features = data.get('features')
+                if features is None or not isinstance(features, list) or len(features) != 32:
+                    return jsonify({'error': 'features must be a list of 32 floats'}), 400
+
+                # Get global model weights
+                model_weights = self.coordinator.get_global_model()
+                if model_weights is None:
+                    return jsonify({'error': 'Global model not available yet'}), 503
+
+                # Build the model (same as client)
+                import tensorflow as tf
+                import numpy as np
+                input_dim = 32
+                model = tf.keras.Sequential([
+                    tf.keras.layers.Input(shape=(input_dim,)),
+                    tf.keras.layers.Dense(128, activation='relu'),
+                    tf.keras.layers.Dense(64, activation='relu'),
+                    tf.keras.layers.Dense(1)
+                ])
+                model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='mse')
+                model.set_weights([np.array(w) for w in model_weights])
+
+                # Prepare input and predict
+                x = np.array(features, dtype=np.float32).reshape(1, -1)
+                pred = model.predict(x)
+                prediction = float(pred[0, 0])
+                return jsonify({'prediction': prediction})
+            except Exception as e:
+                logger.error(f"Error in prediction endpoint: {str(e)}")
+                return jsonify({'error': str(e)}), 500
+    
     def run(self, debug: bool = False):
         """Run the API server"""
         logger.info(f"Starting Federated API server on {self.host}:{self.port}")

webapp/streamlit_app.py

@@ -0,0 +1,57 @@
+import streamlit as st
+import requests
+import numpy as np
+
+st.set_page_config(page_title="Federated Credit Scoring Demo", layout="centered")
+st.title("Federated Credit Scoring Demo (Federated Learning)")
+
+SERVER_URL = st.sidebar.text_input("Server URL", value="http://localhost:8080")
+
+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 ---
+prediction = None
+if submitted:
+    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}")
+        else:
+            st.error(f"Prediction failed: {resp.json().get('error', 'Unknown error')}")
+    except Exception as e:
+        st.error(f"Error connecting to server: {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}")
+
+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.*
+""")