Machine Learning using Python
Interview Questions with Answers

41. What is cross-validation and how is it different from train-test split?

Answer:

• Train-test split divides data once.
• Cross-validation splits data into multiple folds and rotates training/testing sets.

Cross-validation gives a more robust evaluation.

42. How do decision trees work and how can you visualize one in Python?

Answer:
Decision Trees split data by feature thresholds to maximize information gain.

from sklearn.tree import DecisionTreeClassifier, plot_tree
model = DecisionTreeClassifier()
model.fit(X, y)
plot_tree(model)

43. What are pipelines in scikit-learn and why are they used?

Answer:
Pipelines ‘chain preprocessing + modeling’ steps to make the workflow clean and reproducible.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
pipe = Pipeline([('scaler', StandardScaler()), ('model', LogisticRegression())])
pipe.fit(X_train, y_train)

44. What are ensemble methods? Give examples.

Answer:
Ensemble methods combine multiple models for better performance:

• Bagging: e.g., Random Forest
• Boosting: e.g., Gradient Boosting, XGBoost
• Stacking: Combining multiple classifiers via a meta-classifier

45. How do you save and load a trained ML model in Python?

Answer:

import joblib

# Save model

joblib.dump(model, 'model.pkl')

# Load model

model = joblib.load('model.pkl')

46. What is the Curse of Dimensionality and how do you handle it?

Answer:
As dimensions (features) increase, the data becomes sparse, and distance metrics (like Euclidean) become less meaningful.

Solutions:

• Dimensionality reduction (e.g., PCA, t-SNE)
• Feature selection
• Regularization

47. How does Principal Component Analysis (PCA) work in Python?

Answer:
PCA reduces dimensions by projecting data onto new axes (principal components) that maximize variance.

from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

48. Explain the difference between Bagging and Boosting.

Answer:

• Bagging: Builds models independently on random subsets (e.g., Random Forest). Reduces variance.
• Boosting: Builds models sequentially, correcting errors from previous ones (e.g., XGBoost). Reduces bias.

49. What is XGBoost and why is it popular?

Answer:
XGBoost is an optimized gradient boosting algorithm with:

• Regularization (prevents overfitting)
• Parallel computation
• High accuracy and speed

import xgboost as xgb
model = xgb.XGBClassifier()
model.fit(X_train, y_train)

50. How does a Support Vector Machine (SVM) work?

Answer:
SVM finds the best hyperplane that separates classes with the maximum margin.
It can handle non-linear data using kernel tricks like RBF.

51. How do you deal with multicollinearity in features?

Answer:

• Use VIF (Variance Inflation Factor) to detect it.
• Remove or combine correlated features.
• Use regularization (L1 or L2).

52. How can you handle time series data in machine learning?

Answer:

• Feature engineering (lag, rolling mean, date-time features)
• Train-test split must preserve order.
• Models: ARIMA, Prophet, LSTM (for deep learning)

53. What is a ROC Curve and how do you plot it in Python?

Answer:

from sklearn.metrics import roc_curve, auc
fpr, tpr, _ = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)
ROC shows model performance across different thresholds. AUC close to 1 is ideal.

54. What is the difference between batch and online learning?

Answer:

• Batch Learning: Trains on the whole dataset at once.
• Online Learning: Trains incrementally, useful for streaming or large data.

55. How do you prevent data leakage in ML pipelines?

Answer:

• Do data splitting before feature engineering or scaling.
• Use Pipelines to apply the same transformation across training/testing.
• Be careful with time-based features.

56. What is SHAP and how is it used in model interpretability?

Answer:
SHAP (SHapley Additive exPlanations) explains individual predictions by computing feature contributions.

import shap
explainer = shap.Explainer(model, X_train)
shap_values = explainer(X_test)
shap.plots.beeswarm(shap_values)

57. How do you tune hyperparameters using RandomizedSearchCV?

Answer:

from sklearn.model_selection import RandomizedSearchCV
param_grid = {'n_estimators': [100, 200], 'max_depth': [3, 5, 10]}
search = RandomizedSearchCV(model, param_distributions=param_grid, n_iter=5, cv=3)
search.fit(X_train, y_train)

58. How do you handle class imbalance with SMOTE?

Answer:

from imblearn.over_sampling import SMOTE
smote = SMOTE()
X_resampled, y_resampled = smote.fit_resample(X, y)
SMOTE generates synthetic examples for the minority class.

59. What is the difference between Hard and Soft Voting in ensemble models?

Answer:

• Hard Voting: Takes the majority class predicted by classifiers.
• Soft Voting: Takes the average of predicted probabilities.

from sklearn.ensemble import VotingClassifier
VotingClassifier(estimators=[...], voting='soft')

60. How do you deploy a machine learning model as an API?

Answer:

Save the model:

import joblib
joblib.dump(model, 'model.pkl')

Use Flask or FastAPI to create endpoints:

from flask import Flask, request, jsonify
import joblib
app = Flask(__name__)
model = joblib.load('model.pkl')
@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    prediction = model.predict([data['features']])
    return jsonify({'prediction': prediction.tolist()})