Create app.py

app.py

@@ -0,0 +1,343 @@
+import gradio as gr
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from sklearn.model_selection import train_test_split
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime, timedelta
+import random
+import time
+
+class SAPARPredictor:
+    def __init__(self):
+        self.model = None
+        self.training_history = None
+        self.is_trained = False
+        
+    def generate_synthetic_data(self, n_samples=1000):
+        """Generate synthetic SAP AR data"""
+        np.random.seed(42)  # For reproducibility
+        
+        customers = ['CUST001', 'CUST002', 'CUST003', 'CUST004', 'CUST005', 'CUST006', 'CUST007', 'CUST008']
+        
+        data = []
+        for i in range(n_samples):
+            invoice_amount = np.random.uniform(1000, 51000)
+            customer_code = np.random.choice(customers)
+            days_overdue = np.random.randint(0, 120)
+            previous_delays = np.random.randint(0, 5)
+            credit_score = np.random.uniform(0, 100)
+            industry_risk = np.random.uniform(0, 1)
+            seasonality = np.sin((i % 365) * 2 * np.pi / 365)
+            
+            # Create correlation between features and payment probability
+            payment_prob = 0.7
+            payment_prob -= min(days_overdue / 100, 0.4)
+            payment_prob -= min(previous_delays / 10, 0.3)
+            payment_prob += (credit_score - 50) / 200
+            payment_prob -= industry_risk * 0.2
+            payment_prob += seasonality * 0.1
+            payment_prob = max(0.05, min(0.95, payment_prob))
+            
+            paid_on_time = 1 if np.random.random() < payment_prob else 0
+            
+            data.append({
+                'invoice_amount': invoice_amount / 50000,  # Normalize
+                'days_overdue': days_overdue / 120,  # Normalize
+                'previous_delays': previous_delays / 5,  # Normalize
+                'credit_score': credit_score / 100,  # Already normalized
+                'industry_risk': industry_risk,
+                'seasonality': (seasonality + 1) / 2,  # Normalize to 0-1
+                'paid_on_time': paid_on_time
+            })
+        
+        return pd.DataFrame(data)
+    
+    def train_model(self, progress=gr.Progress()):
+        """Train the ML model with progress tracking"""
+        progress(0, desc="Generating synthetic data...")
+        
+        # Generate training data
+        df = self.generate_synthetic_data(1000)
+        time.sleep(1)  # Simulate data generation time
+        
+        progress(0.1, desc="Preparing features and labels...")
+        
+        # Prepare features and labels
+        feature_columns = ['invoice_amount', 'days_overdue', 'previous_delays', 
+                          'credit_score', 'industry_risk', 'seasonality']
+        X = df[feature_columns].values
+        y = df['paid_on_time'].values
+        
+        # Split data
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        
+        progress(0.2, desc="Building neural network...")
+        
+        # Create model
+        self.model = tf.keras.Sequential([
+            tf.keras.layers.Dense(32, activation='relu', input_shape=(6,)),
+            tf.keras.layers.Dropout(0.2),
+            tf.keras.layers.Dense(16, activation='relu'),
+            tf.keras.layers.Dropout(0.2),
+            tf.keras.layers.Dense(1, activation='sigmoid')
+        ])
+        
+        self.model.compile(
+            optimizer=tf.keras.optimizers.Adam(0.001),
+            loss='binary_crossentropy',
+            metrics=['accuracy']
+        )
+        
+        progress(0.3, desc="Training model...")
+        
+        # Train model
+        history = self.model.fit(
+            X_train, y_train,
+            epochs=50,
+            batch_size=32,
+            validation_split=0.2,
+            verbose=0
+        )
+        
+        progress(0.8, desc="Evaluating model...")
+        
+        # Make predictions on test set
+        y_pred_proba = self.model.predict(X_test)
+        y_pred = (y_pred_proba > 0.5).astype(int)
+        
+        # Calculate metrics
+        accuracy = accuracy_score(y_test, y_pred)
+        precision = precision_score(y_test, y_pred)
+        recall = recall_score(y_test, y_pred)
+        f1 = f1_score(y_test, y_pred)
+        
+        self.training_history = history.history
+        self.is_trained = True
+        
+        progress(1.0, desc="Training completed!")
+        
+        # Create training visualization
+        fig = go.Figure()
+        
+        epochs = list(range(1, len(history.history['accuracy']) + 1))
+        
+        fig.add_trace(go.Scatter(
+            x=epochs,
+            y=history.history['accuracy'],
+            mode='lines+markers',
+            name='Training Accuracy',
+            line=dict(color='#007bff', width=3),
+            marker=dict(size=6)
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=epochs,
+            y=history.history['val_accuracy'],
+            mode='lines+markers',
+            name='Validation Accuracy',
+            line=dict(color='#28a745', width=3),
+            marker=dict(size=6)
+        ))
+        
+        fig.update_layout(
+            title='Model Training Progress',
+            xaxis_title='Epoch',
+            yaxis_title='Accuracy',
+            template='plotly_white',
+            height=400,
+            hovermode='x unified'
+        )
+        
+        # Create metrics summary
+        metrics_text = f"""
+        ## 🎯 Model Performance Metrics
+        
+        - **Accuracy**: {accuracy:.1%}
+        - **Precision**: {precision:.1%}
+        - **Recall**: {recall:.1%}
+        - **F1 Score**: {f1:.1%}
+        
+        ✅ Model trained successfully on 1,000 synthetic SAP AR records!
+        """
+        
+        return fig, metrics_text, gr.update(interactive=True)
+    
+    def generate_unpaid_invoices(self):
+        """Generate sample unpaid invoices for prediction"""
+        customers = ['SAP-CUST001', 'SAP-CUST002', 'SAP-CUST003', 'SAP-CUST004', 'SAP-CUST005']
+        
+        invoices = []
+        for i in range(15):
+            invoice_id = f"INV-{datetime.now().strftime('%Y%m%d')}-{i:03d}"
+            customer = random.choice(customers)
+            amount = random.randint(5000, 50000)
+            days_overdue = random.randint(0, 90)
+            previous_delays = random.randint(0, 4)
+            credit_score = random.randint(40, 100)
+            
+            invoices.append({
+                'Invoice ID': invoice_id,
+                'Customer': customer,
+                'Amount ($)': amount,
+                'Days Overdue': days_overdue,
+                'Previous Delays': previous_delays,
+                'Credit Score': credit_score,
+                'Industry Risk': round(random.random(), 3),
+                'Seasonality': round(random.random(), 3)
+            })
+        
+        return pd.DataFrame(invoices)
+    
+    def make_predictions(self):
+        """Make predictions on unpaid invoices"""
+        if not self.is_trained:
+            return None, "❌ Please train the model first!"
+        
+        # Generate unpaid invoices
+        df = self.generate_unpaid_invoices()
+        
+        # Prepare features for prediction
+        features = []
+        for _, row in df.iterrows():
+            features.append([
+                row['Amount ($)'] / 50000,  # Normalize
+                row['Days Overdue'] / 120,  # Normalize
+                row['Previous Delays'] / 5,  # Normalize
+                row['Credit Score'] / 100,  # Normalize
+                row['Industry Risk'],
+                row['Seasonality']
+            ])
+        
+        # Make predictions
+        predictions = self.model.predict(np.array(features))
+        
+        # Add predictions to dataframe
+        df['Payment Probability'] = [f"{p[0]:.1%}" for p in predictions]
+        df['Prediction'] = ['✅ Will Pay' if p[0] > 0.5 else '❌ Risk of Default' for p in predictions]
+        df['Risk Level'] = ['🟢 Low' if p[0] > 0.7 else '🟡 Medium' if p[0] > 0.4 else '🔴 High' for p in predictions]
+        
+        # Format amount column
+        df['Amount ($)'] = df['Amount ($)'].apply(lambda x: f"${x:,}")
+        
+        # Create probability distribution chart
+        prob_values = [p[0] for p in predictions]
+        
+        fig = go.Figure(data=[
+            go.Histogram(
+                x=prob_values,
+                nbinsx=20,
+                marker_color='rgba(0, 123, 255, 0.7)',
+                marker_line_color='rgba(0, 123, 255, 1)',
+                marker_line_width=1
+            )
+        ])
+        
+        fig.update_layout(
+            title='Distribution of Payment Probabilities',
+            xaxis_title='Payment Probability',
+            yaxis_title='Number of Invoices',
+            template='plotly_white',
+            height=300
+        )
+        
+        success_msg = f"🔮 Generated predictions for {len(df)} unpaid invoices!"
+        
+        return df, success_msg, fig
+
+# Initialize the predictor
+predictor = SAPARPredictor()
+
+# Create Gradio interface
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="green",
+        neutral_hue="slate"
+    ),
+    title="SAP AR ML Prediction Demo",
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .main-header {
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+    }
+    """
+) as demo:
+    
+    gr.HTML("""
+    <div class="main-header">
+        <h1>🏢 SAP Account Receivable ML Prediction Demo</h1>
+        <p style="font-size: 1.1rem; color: #666;">
+            Machine Learning-powered invoice payment prediction system using TensorFlow
+        </p>
+    </div>
+    """)
+    
+    with gr.Tabs() as tabs:
+        
+        with gr.Tab("🎯 Model Training", id=0):
+            gr.Markdown("""
+            ### Train ML Model
+            Train a neural network on synthetic SAP AR data to predict invoice payment likelihood.
+            The model uses features like invoice amount, days overdue, customer credit score, and more.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    train_btn = gr.Button(
+                        "🚀 Train ML Model", 
+                        variant="primary", 
+                        size="lg"
+                    )
+                    
+                with gr.Column(scale=2):
+                    metrics_display = gr.Markdown("")
+            
+            training_plot = gr.Plot(label="Training Progress")
+            predict_btn = gr.Button(
+                "🔮 Make Predictions", 
+                variant="secondary", 
+                interactive=False,
+                size="lg"
+            )
+        
+        with gr.Tab("📊 Predictions", id=1):
+            gr.Markdown("""
+            ### Invoice Payment Predictions
+            View real-time predictions for unpaid invoices using the trained ML model.
+            """)
+            
+            prediction_status = gr.Markdown("")
+            predictions_df = gr.Dataframe(
+                label="Invoice Predictions",
+                interactive=False,
+                wrap=True
+            )
+            probability_plot = gr.Plot(label="Probability Distribution")
+    
+    # Event handlers
+    train_btn.click(
+        fn=predictor.train_model,
+        outputs=[training_plot, metrics_display, predict_btn]
+    )
+    
+    predict_btn.click(
+        fn=predictor.make_predictions,
+        outputs=[predictions_df, prediction_status, probability_plot]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()