FAQ & Interview Q&A

Answer: Random Forest is an excellent choice for structured financial data like credit risk prediction for several reasons:

• High Accuracy: Random Forest combines multiple decision trees, which makes it very accurate for classification problems. It often performs better than a single decision tree.
• Prevents Overfitting: By using multiple trees and averaging their predictions, Random Forest reduces the risk of overfitting (memorizing the training data instead of learning general patterns).
• Handles Mixed Data Types: It works well with both numerical features (like age and income) and categorical features (like loan intent) without needing extensive preprocessing.
• Feature Importance: Random Forest can tell us which features are most important for predictions (e.g., income might be more important than age), which helps with interpretability.
• Robust to Outliers: Financial data often has outliers (unusual values), and Random Forest handles them better than some other algorithms.

Why not Deep Learning? Deep Learning (neural networks) is great for complex data like images or text, but for structured tabular data like credit risk, Random Forest often performs just as well and is simpler, faster to train, and easier to interpret.

Answer: The safety percentage comes from the predict_proba() method in scikit-learn. Here's how it works:

Explanation:

• predict_proba() returns probabilities for each possible outcome. For our binary classification (SAFE vs RISKY), it returns two probabilities that add up to 100%.
• For example, if the model predicts:
  • 80% chance of SAFE (class 0)
  • 20% chance of RISKY (class 1)
  Then the safety percentage is 80%.
• Higher percentage = More confident = Lower risk

This percentage helps users understand not just the prediction (SAFE or RISKY), but also how confident the model is. A 95% safety score means the model is very confident the applicant is safe, while a 55% safety score means it's less certain.

Answer:

• predict(): Returns the final prediction (SAFE or RISKY). It gives you the answer: "This applicant is SAFE" or "This applicant is RISKY."
• predict_proba(): Returns the probabilities for each possible outcome. It tells you: "80% chance of SAFE, 20% chance of RISKY."

Example:

We use both in our application: predict() for the final answer and predict_proba() for the confidence percentage.

Answer: We compressed the model to meet file size limits on GitHub and Render. The compression reduces file size from ~50MB to ~25MB, but it does NOT affect the model's accuracy at all!

How compression works: Joblib compression uses algorithms (similar to ZIP compression) to store the model more efficiently. It removes redundant information and uses efficient storage formats, but all the model's "knowledge" (the decision trees and their parameters) remains exactly the same.

Think of it like this: Compressing a document file makes it smaller, but when you open it, the content is identical. Same with our model - smaller file, same predictions!

Answer: Good question! In a production system, we should add validation. Currently, the HTML form uses required attributes to ensure fields are filled, but we could add more validation:

• Frontend Validation: Use HTML5 validation (e.g., min="0" for age and income) or JavaScript to check values before submission.
• Backend Validation: In Flask, we can check if values are reasonable (e.g., age between 18-100, income > 0) before making predictions.

Invalid data could lead to incorrect predictions, so validation is important for a real-world application!

Answer: This is a demonstration project. For real production use in banks, you would need:

• More Data: Train on much larger, more diverse datasets
• Regular Retraining: Update the model periodically as economic conditions change
• Compliance: Meet financial regulations (fair lending, explainability requirements)
• Security: Encrypt data, secure APIs, handle sensitive financial information
• Monitoring: Track model performance, detect drift, set up alerts
• Explainability: Provide explanations for why applicants were approved/rejected

However, this project demonstrates the core concepts and could serve as a foundation for more advanced systems!

Answer: Random Forest is like asking multiple experts for their opinion and taking a vote:

1. Multiple Trees: Instead of one decision tree, Random Forest creates many decision trees (like 100 or more).
2. Randomness: Each tree is trained on a random subset of the data and uses random features, so each tree learns slightly different patterns.
3. Voting: When making a prediction, all trees vote. The majority vote becomes the final prediction.
4. Result: This ensemble approach is more accurate and robust than a single tree.

Why it works: If one tree makes a mistake, the other trees can correct it. It's like asking 100 doctors for a diagnosis - the majority opinion is usually more reliable than asking just one doctor.

Answer: Feature engineering is creating new features from existing ones to help the model make better predictions.

Why interest_burden? A person's ability to pay back a loan depends not just on their income, but on how much of that income goes toward loan payments. Someone earning $50,000 with a $500/month payment is in better shape than someone earning $50,000 with a $2,000/month payment.

By calculating interest_burden = (loan_amnt * interest_rate) / income, we create a single feature that captures this relationship. The model can then easily learn: "Lower interest burden = Lower risk."

This is feature engineering: We're not just using raw data (income, loan amount, interest rate separately), but creating a meaningful derived feature that the model can use more effectively.

Answer: A Pipeline chains together multiple data processing steps and the model training into one object.

Benefits:

• Organization: All preprocessing steps are in one place, making code cleaner
• Consistency: The same preprocessing is applied during training AND prediction
• Easier Deployment: You save the entire pipeline (including preprocessing), so you don't have to remember to apply the same steps when making predictions
• Prevents Bugs: Can't forget a preprocessing step if it's in the pipeline!

Example: Our pipeline does: Impute missing values → Scale features → Encode categories → Train Random Forest. All in one object!

Answer: Here's the flow:

1. User Action: User fills out form and clicks "Submit"
2. HTTP Request: Browser sends POST request to /predict with form data
3. Flask Receives: Flask's @app.route('/predict') decorator catches the request
4. Process: Flask extracts data using request.form, processes it, runs through model
5. HTTP Response: Flask sends back HTML page with prediction result
6. Display: Browser receives response and displays the result to the user

This all happens in milliseconds! Flask handles the web server details so we can focus on the ML logic.