add: model

model.py

@@ -0,0 +1,322 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import pandas as pd
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+class LoanPredictionANN(nn.Module):
+    """
+    Neural Network for Loan Prediction
+    
+    Architecture:
+    - Input: 9 features
+    - Hidden Layer 1: 64 neurons (ReLU)
+    - Hidden Layer 2: 32 neurons (ReLU) 
+    - Hidden Layer 3: 16 neurons (ReLU)
+    - Output: 1 neuron (Sigmoid)
+    - Dropout: Progressive rates [0.3, 0.2, 0.1]
+    """
+    
+    def __init__(self, input_size=9, hidden_sizes=[64, 32, 16], dropout_rates=[0.3, 0.2, 0.1]):
+        super(LoanPredictionANN, self).__init__()
+        
+        self.input_size = input_size
+        self.hidden_sizes = hidden_sizes
+        self.dropout_rates = dropout_rates
+        
+        # Input layer to first hidden layer
+        self.fc1 = nn.Linear(input_size, hidden_sizes[0])
+        self.dropout1 = nn.Dropout(dropout_rates[0])
+        
+        # Hidden layers
+        self.fc2 = nn.Linear(hidden_sizes[0], hidden_sizes[1])
+        self.dropout2 = nn.Dropout(dropout_rates[1])
+        
+        self.fc3 = nn.Linear(hidden_sizes[1], hidden_sizes[2])
+        self.dropout3 = nn.Dropout(dropout_rates[2])
+        
+        # Output layer
+        self.fc4 = nn.Linear(hidden_sizes[2], 1)
+        
+        # Initialize weights
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        """Initialize weights using Xavier/Glorot initialization"""
+        for module in self.modules():
+            if isinstance(module, nn.Linear):
+                nn.init.xavier_uniform_(module.weight)
+                nn.init.zeros_(module.bias)
+    
+    def forward(self, x):
+        """Forward pass through the network"""
+        # First hidden layer
+        x = F.relu(self.fc1(x))
+        x = self.dropout1(x)
+        
+        # Second hidden layer
+        x = F.relu(self.fc2(x))
+        x = self.dropout2(x)
+        
+        # Third hidden layer
+        x = F.relu(self.fc3(x))
+        x = self.dropout3(x)
+        
+        # Output layer
+        x = torch.sigmoid(self.fc4(x))
+        
+        return x
+    
+    def predict_proba(self, x):
+        """Get prediction probabilities"""
+        self.eval()
+        with torch.no_grad():
+            if isinstance(x, np.ndarray):
+                x = torch.FloatTensor(x)
+            return self.forward(x).numpy()
+    
+    def predict(self, x, threshold=0.5):
+        """Get binary predictions"""
+        probabilities = self.predict_proba(x)
+        return (probabilities >= threshold).astype(int)
+
+
+class LoanPredictionLightANN(nn.Module):
+    """
+    Lighter version of the neural network for faster training
+    
+    Architecture:
+    - Input: 9 features
+    - Hidden Layer 1: 32 neurons (ReLU)
+    - Hidden Layer 2: 16 neurons (ReLU)
+    - Output: 1 neuron (Sigmoid)
+    - Dropout: [0.2, 0.1]
+    """
+    
+    def __init__(self, input_size=9):
+        super(LoanPredictionLightANN, self).__init__()
+        
+        self.fc1 = nn.Linear(input_size, 32)
+        self.dropout1 = nn.Dropout(0.2)
+        
+        self.fc2 = nn.Linear(32, 16)
+        self.dropout2 = nn.Dropout(0.1)
+        
+        self.fc3 = nn.Linear(16, 1)
+        
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        for module in self.modules():
+            if isinstance(module, nn.Linear):
+                nn.init.xavier_uniform_(module.weight)
+                nn.init.zeros_(module.bias)
+    
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = self.dropout1(x)
+        
+        x = F.relu(self.fc2(x))
+        x = self.dropout2(x)
+        
+        x = torch.sigmoid(self.fc3(x))
+        
+        return x
+
+
+class LoanPredictionDeepANN(nn.Module):
+    """
+    Deeper version for maximum performance
+    
+    Architecture:
+    - Input: 9 features
+    - Hidden Layer 1: 128 neurons (ReLU)
+    - Hidden Layer 2: 64 neurons (ReLU)
+    - Hidden Layer 3: 32 neurons (ReLU)
+    - Hidden Layer 4: 16 neurons (ReLU)
+    - Output: 1 neuron (Sigmoid)
+    - Dropout: [0.3, 0.3, 0.2, 0.1]
+    """
+    
+    def __init__(self, input_size=9):
+        super(LoanPredictionDeepANN, self).__init__()
+        
+        self.fc1 = nn.Linear(input_size, 128)
+        self.dropout1 = nn.Dropout(0.3)
+        
+        self.fc2 = nn.Linear(128, 64)
+        self.dropout2 = nn.Dropout(0.3)
+        
+        self.fc3 = nn.Linear(64, 32)
+        self.dropout3 = nn.Dropout(0.2)
+        
+        self.fc4 = nn.Linear(32, 16)
+        self.dropout4 = nn.Dropout(0.1)
+        
+        self.fc5 = nn.Linear(16, 1)
+        
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        for module in self.modules():
+            if isinstance(module, nn.Linear):
+                nn.init.xavier_uniform_(module.weight)
+                nn.init.zeros_(module.bias)
+    
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = self.dropout1(x)
+        
+        x = F.relu(self.fc2(x))
+        x = self.dropout2(x)
+        
+        x = F.relu(self.fc3(x))
+        x = self.dropout3(x)
+        
+        x = F.relu(self.fc4(x))
+        x = self.dropout4(x)
+        
+        x = torch.sigmoid(self.fc5(x))
+        
+        return x
+
+
+def load_processed_data(data_path='data/processed'):
+    """Load the processed training and test data"""
+    train_data = pd.read_csv(f'{data_path}/train_data_scaled.csv')
+    test_data = pd.read_csv(f'{data_path}/test_data_scaled.csv')
+    
+    # Separate features and target
+    feature_columns = [col for col in train_data.columns if col != 'loan_repaid']
+    
+    X_train = train_data[feature_columns].values
+    y_train = train_data['loan_repaid'].values
+    
+    X_test = test_data[feature_columns].values
+    y_test = test_data['loan_repaid'].values
+    
+    return X_train, y_train, X_test, y_test, feature_columns
+
+
+def calculate_class_weights(y):
+    """Calculate class weights for handling imbalanced data"""
+    from sklearn.utils.class_weight import compute_class_weight
+    
+    classes = np.unique(y)
+    weights = compute_class_weight('balanced', classes=classes, y=y)
+    return torch.FloatTensor(weights)
+
+
+def evaluate_model(model, X_test, y_test, threshold=0.5):
+    """Comprehensive model evaluation"""
+    model.eval()
+    
+    # Get predictions
+    with torch.no_grad():
+        X_test_tensor = torch.FloatTensor(X_test)
+        y_pred_proba = model(X_test_tensor).numpy().flatten()
+        y_pred = (y_pred_proba >= threshold).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)
+    auc_roc = roc_auc_score(y_test, y_pred_proba)
+    
+    metrics = {
+        'accuracy': accuracy,
+        'precision': precision,
+        'recall': recall,
+        'f1_score': f1,
+        'auc_roc': auc_roc
+    }
+    
+    return metrics, y_pred, y_pred_proba
+
+
+def plot_training_history(train_losses, val_losses, train_accuracies, val_accuracies):
+    """Plot training history"""
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
+    
+    # Loss plot
+    ax1.plot(train_losses, label='Training Loss', color='blue')
+    ax1.plot(val_losses, label='Validation Loss', color='red')
+    ax1.set_title('Model Loss')
+    ax1.set_xlabel('Epoch')
+    ax1.set_ylabel('Loss')
+    ax1.legend()
+    ax1.grid(True)
+    
+    # Accuracy plot
+    ax2.plot(train_accuracies, label='Training Accuracy', color='blue')
+    ax2.plot(val_accuracies, label='Validation Accuracy', color='red')
+    ax2.set_title('Model Accuracy')
+    ax2.set_xlabel('Epoch')
+    ax2.set_ylabel('Accuracy')
+    ax2.legend()
+    ax2.grid(True)
+    
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_confusion_matrix(y_true, y_pred, class_names=['Charged Off', 'Fully Paid']):
+    """Plot confusion matrix"""
+    from sklearn.metrics import confusion_matrix
+    
+    cm = confusion_matrix(y_true, y_pred)
+    
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                xticklabels=class_names, yticklabels=class_names)
+    plt.title('Confusion Matrix')
+    plt.xlabel('Predicted')
+    plt.ylabel('Actual')
+    plt.show()
+    
+    return cm
+
+
+def model_summary(model):
+    """Print model architecture summary"""
+    print("=" * 60)
+    print("MODEL ARCHITECTURE SUMMARY")
+    print("=" * 60)
+    
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    
+    print(f"Model: {model.__class__.__name__}")
+    print(f"Total parameters: {total_params:,}")
+    print(f"Trainable parameters: {trainable_params:,}")
+    print("\nLayer Details:")
+    print("-" * 40)
+    
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear):
+            print(f"{name}: {module}")
+        elif isinstance(module, nn.Dropout):
+            print(f"{name}: {module}")
+    
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    # Example usage
+    print("Loading processed data...")
+    X_train, y_train, X_test, y_test, feature_names = load_processed_data()
+    
+    print(f"Training data shape: {X_train.shape}")
+    print(f"Test data shape: {X_test.shape}")
+    print(f"Feature names: {feature_names}")
+    
+    # Create model
+    model = LoanPredictionANN()
+    model_summary(model)
+    
+    print("\nModel created successfully!")
+    print("Use train.py to train the model.")