Lead Data Scientist Interview Questions: Complete Guide

# Example: Mentorship tracking system
class MentorshipTracker:
    def __init__(self):
        self.mentees = {}
    
    def create_development_plan(self, mentee_name, current_level, target_level, timeline_months):
        """Create individual development plan"""
        plan = {
            'mentee': mentee_name,
            'current_level': current_level,
            'target_level': target_level,
            'timeline_months': timeline_months,
            'skills_to_develop': [],
            'projects': [],
            'milestones': [],
            'check_ins': []
        }
        self.mentees[mentee_name] = plan
        return plan
    
    def add_skill_goal(self, mentee_name, skill, current_proficiency, target_proficiency):
        """Add skill development goal"""
        goal = {
            'skill': skill,
            'current': current_proficiency,
            'target': target_proficiency,
            'resources': [],
            'progress': 0
        }
        self.mentees[mentee_name]['skills_to_develop'].append(goal)
    
    def log_check_in(self, mentee_name, date, notes, progress_rating):
        """Log mentorship check-in"""
        check_in = {
            'date': date,
            'notes': notes,
            'progress_rating': progress_rating,
            'action_items': []
        }
        self.mentees[mentee_name]['check_ins'].append(check_in)
    
    def get_progress_summary(self, mentee_name):
        """Get mentee progress summary"""
        plan = self.mentees[mentee_name]
        avg_progress = sum(s['progress'] for s in plan['skills_to_develop']) / len(plan['skills_to_develop'])
        return {
            'mentee': mentee_name,
            'overall_progress': avg_progress,
            'skills_in_progress': len([s for s in plan['skills_to_develop'] if 0 < s['progress'] < 100]),
            'skills_completed': len([s for s in plan['skills_to_develop'] if s['progress'] == 100]),
            'total_check_ins': len(plan['check_ins'])
        }

# Example usage
tracker = MentorshipTracker()
tracker.create_development_plan('Alice', 'Junior DS', 'Mid-level DS', 12)
tracker.add_skill_goal('Alice', 'Deep Learning', current_proficiency=2, target_proficiency=4)
tracker.add_skill_goal('Alice', 'Model Deployment', current_proficiency=1, target_proficiency=3)
tracker.log_check_in('Alice', '2025-01-15', 'Completed PyTorch course', progress_rating=7)

summary = tracker.get_progress_summary('Alice')
print(f"Progress summary: {summary}")

# Example: ML Platform Architecture Design
class MLPlatformArchitecture:
    def __init__(self):
        self.components = {
            'data_layer': {
                'data_lake': 'S3/GCS/Azure Blob',
                'data_warehouse': 'Snowflake/BigQuery/Redshift',
                'feature_store': 'Feast/Tecton',
                'data_catalog': 'DataHub/Amundsen'
            },
            'compute_layer': {
                'training': 'SageMaker/Vertex AI/AzureML',
                'batch_inference': 'Spark/Dask',
                'real_time_serving': 'Kubernetes/SageMaker Endpoints'
            },
            'ml_ops': {
                'experiment_tracking': 'MLflow/W&B',
                'model_registry': 'MLflow/SageMaker',
                'pipeline_orchestration': 'Airflow/Kubeflow',
                'monitoring': 'Prometheus/Grafana'
            },
            'governance': {
                'version_control': 'Git/DVC',
                'access_control': 'IAM/RBAC',
                'audit_logging': 'CloudTrail/StackDriver'
            }
        }
    
    def design_for_scale(self, expected_models, expected_requests_per_sec):
        """Design architecture based on scale requirements"""
        recommendations = []
        
        if expected_models > 100:
            recommendations.append("Implement automated model registry and lifecycle management")
            recommendations.append("Use feature store to reduce redundancy")
        
        if expected_requests_per_sec > 1000:
            recommendations.append("Deploy models on Kubernetes with auto-scaling")
            recommendations.append("Implement caching layer for frequent predictions")
            recommendations.append("Use model serving optimization (TensorRT, ONNX)")
        
        return recommendations
    
    def estimate_costs(self, team_size, data_volume_tb, model_count):
        """Estimate infrastructure costs"""
        # Simplified cost estimation
        costs = {
            'storage': data_volume_tb * 23,  # $23/TB/month
            'compute_training': model_count * 500,  # $500/model/month
            'compute_serving': model_count * 200,  # $200/model/month
            'tools_licenses': team_size * 100,  # $100/person/month
        }
        costs['total'] = sum(costs.values())
        return costs

# Example usage
platform = MLPlatformArchitecture()
recommendations = platform.design_for_scale(expected_models=150, expected_requests_per_sec=2000)
print("Architecture Recommendations:")
for rec in recommendations:
    print(f"- {rec}")

costs = platform.estimate_costs(team_size=10, data_volume_tb=50, model_count=20)
print(f"\nEstimated Monthly Costs: ${costs['total']:,.0f}")

import pandas as pd
import numpy as np

class ProjectPrioritization:
    def __init__(self):
        self.projects = []
    
    def add_project(self, name, business_value, feasibility, urgency, 
                   resource_requirement, strategic_alignment):
        """Add project with scoring criteria"""
        project = {
            'name': name,
            'business_value': business_value,  # 1-10
            'feasibility': feasibility,  # 1-10
            'urgency': urgency,  # 1-10
            'resource_requirement': resource_requirement,  # 1-10 (lower is better)
            'strategic_alignment': strategic_alignment  # 1-10
        }
        
        # Calculate priority score
        # Higher business value, feasibility, urgency, and alignment increase score
        # Higher resource requirement decreases score
        project['priority_score'] = (
            business_value * 0.3 +
            feasibility * 0.25 +
            urgency * 0.2 +
            strategic_alignment * 0.15 +
            (10 - resource_requirement) * 0.1
        )
        
        self.projects.append(project)
    
    def get_prioritized_projects(self):
        """Return projects sorted by priority"""
        df = pd.DataFrame(self.projects)
        return df.sort_values('priority_score', ascending=False)
    
    def allocate_resources(self, available_capacity):
        """Allocate resources based on priority and capacity"""
        df = self.get_prioritized_projects()
        allocated = []
        remaining_capacity = available_capacity
        
        for _, project in df.iterrows():
            if project['resource_requirement'] <= remaining_capacity:
                allocated.append(project['name'])
                remaining_capacity -= project['resource_requirement']
        
        return {
            'allocated_projects': allocated,
            'capacity_used': available_capacity - remaining_capacity,
            'capacity_remaining': remaining_capacity
        }

# Example usage
prioritizer = ProjectPrioritization()

# Add projects
prioritizer.add_project(
    name='Customer Churn Prediction',
    business_value=9,
    feasibility=8,
    urgency=7,
    resource_requirement=5,
    strategic_alignment=9
)

prioritizer.add_project(
    name='Recommendation System',
    business_value=8,
    feasibility=6,
    urgency=5,
    resource_requirement=8,
    strategic_alignment=7
)

prioritizer.add_project(
    name='Fraud Detection',
    business_value=10,
    feasibility=7,
    urgency=9,
    resource_requirement=6,
    strategic_alignment=10
)

prioritizer.add_project(
    name='Demand Forecasting',
    business_value=7,
    feasibility=9,
    urgency=6,
    resource_requirement=4,
    strategic_alignment=6
)

# Get prioritized list
prioritized = prioritizer.get_prioritized_projects()
print("Prioritized Projects:")
print(prioritized[['name', 'priority_score', 'business_value', 'feasibility']].to_string(index=False))

# Allocate resources (assuming 15 units of capacity)
allocation = prioritizer.allocate_resources(available_capacity=15)
print(f"\nAllocated Projects: {allocation['allocated_projects']}")
print(f"Capacity Used: {allocation['capacity_used']}/15")

class StakeholderPresentation:
    def __init__(self, project_name, audience_type):
        self.project_name = project_name
        self.audience_type = audience_type
    
    def create_executive_summary(self, business_problem, solution, impact, timeline, investment):
        """Create executive-friendly summary"""
        summary = f"""
# {self.project_name}

## Business Problem
{business_problem}

## Proposed Solution
{solution}

## Expected Impact
{impact}

## Timeline & Investment
- Timeline: {timeline}
- Investment Required: {investment}

## Key Risks & Mitigation
- Data quality: Implement data validation pipeline
- Model accuracy: Establish baseline and success metrics
- Adoption: User training and change management plan
"""
        return summary
    
    def create_technical_analogy(self, ml_concept):
        """Create non-technical analogies for ML concepts"""
        analogies = {
            'supervised_learning': "Like teaching a child with flashcards - we show examples with correct answers until they learn the pattern",
            'neural_network': "Like a team of specialists, each layer focuses on different aspects and passes information to the next",
            'overfitting': "Like memorizing answers instead of understanding concepts - works on practice tests but fails on new questions",
            'feature_engineering': "Like choosing the right ingredients for a recipe - the quality of inputs determines the quality of output",
            'model_deployment': "Like launching a new product - we test thoroughly, roll out gradually, and monitor performance"
        }
        return analogies.get(ml_concept, "Concept not found")
    
    def quantify_business_impact(self, metric_name, baseline, predicted, confidence_interval):
        """Present business impact with uncertainty"""
        improvement = ((predicted - baseline) / baseline) * 100
        
        report = f"""
## Business Impact: {metric_name}

- **Current State**: {baseline:,.0f}
- **Predicted State**: {predicted:,.0f}
- **Expected Improvement**: {improvement:.1f}%
- **Confidence Range**: {confidence_interval[0]:.1f}% to {confidence_interval[1]:.1f}%

This improvement translates to significant business value while accounting for model uncertainty.
"""
        return report

# Example usage
presentation = StakeholderPresentation("Customer Churn Prediction", "Executive")

summary = presentation.create_executive_summary(
    business_problem="Losing 15% of customers annually, costing $5M in revenue",
    solution="ML model to predict churn risk 3 months in advance, enabling proactive retention",
    impact="Reduce churn by 20-30%, saving $1-1.5M annually",
    timeline="3 months development, 1 month pilot, 2 months rollout",
    investment="$200K (team time + infrastructure)"
)

print(summary)

analogy = presentation.create_technical_analogy('overfitting')
print(f"\nOverfitting Analogy: {analogy}")

impact = presentation.quantify_business_impact(
    metric_name="Customer Retention Rate",
    baseline=85,
    predicted=88,
    confidence_interval=(87.5, 88.5)
)
print(impact)

import numpy as np
from sklearn.metrics import confusion_matrix

class FairnessAuditor:
    def __init__(self, model, sensitive_attribute):
        self.model = model
        self.sensitive_attribute = sensitive_attribute
    
    def calculate_demographic_parity(self, X, y_pred, sensitive_feature):
        """Calculate demographic parity difference"""
        groups = np.unique(sensitive_feature)
        positive_rates = {}
        
        for group in groups:
            group_mask = sensitive_feature == group
            positive_rate = np.mean(y_pred[group_mask])
            positive_rates[group] = positive_rate
        
        max_rate = max(positive_rates.values())
        min_rate = min(positive_rates.values())
        parity_difference = max_rate - min_rate
        
        return {
            'positive_rates': positive_rates,
            'parity_difference': parity_difference,
            'is_fair': parity_difference < 0.1  # 10% threshold
        }
    
    def calculate_equal_opportunity(self, y_true, y_pred, sensitive_feature):
        """Calculate equal opportunity difference (TPR across groups)"""
        groups = np.unique(sensitive_feature)
        tpr_by_group = {}
        
        for group in groups:
            group_mask = sensitive_feature == group
            y_true_group = y_true[group_mask]
            y_pred_group = y_pred[group_mask]
            
            # True Positive Rate
            tp = np.sum((y_true_group == 1) & (y_pred_group == 1))
            fn = np.sum((y_true_group == 1) & (y_pred_group == 0))
            tpr = tp / (tp + fn) if (tp + fn) > 0 else 0
            
            tpr_by_group[group] = tpr
        
        max_tpr = max(tpr_by_group.values())
        min_tpr = min(tpr_by_group.values())
        eo_difference = max_tpr - min_tpr
        
        return {
            'tpr_by_group': tpr_by_group,
            'equal_opportunity_difference': eo_difference,
            'is_fair': eo_difference < 0.1
        }
    
    def generate_fairness_report(self, X, y_true, y_pred, sensitive_feature):
        """Generate comprehensive fairness report"""
        dp = self.calculate_demographic_parity(X, y_pred, sensitive_feature)
        eo = self.calculate_equal_opportunity(y_true, y_pred, sensitive_feature)
        
        report = f"""
# Fairness Audit Report

## Demographic Parity
- Positive rates by group: {dp['positive_rates']}
- Parity difference: {dp['parity_difference']:.3f}
- Fair (< 0.1): {dp['is_fair']}

## Equal Opportunity
- TPR by group: {eo['tpr_by_group']}
- EO difference: {eo['equal_opportunity_difference']:.3f}
- Fair (< 0.1): {eo['is_fair']}

## Recommendations
"""
        if not dp['is_fair']:
            report += "- Address demographic parity issues through resampling or threshold adjustment\n"
        if not eo['is_fair']:
            report += "- Address equal opportunity issues through calibration or fairness constraints\n"
        
        return report

# Example usage
np.random.seed(42)
n_samples = 1000

# Simulate data with bias
sensitive_feature = np.random.choice(['Group A', 'Group B'], n_samples, p=[0.7, 0.3])
y_true = np.random.randint(0, 2, n_samples)

# Simulate biased predictions (Group B has lower positive rate)
y_pred = y_true.copy()
group_b_mask = sensitive_feature == 'Group B'
y_pred[group_b_mask] = np.where(
    np.random.random(np.sum(group_b_mask)) < 0.3,
    1 - y_pred[group_b_mask],
    y_pred[group_b_mask]
)

auditor = FairnessAuditor(model=None, sensitive_attribute='group')
report = auditor.generate_fairness_report(None, y_true, y_pred, sensitive_feature)
print(report)

class DataScienceRoadmap:
    def __init__(self, company_name):
        self.company_name = company_name
        self.initiatives = {
            'quick_wins': [],
            'medium_term': [],
            'long_term': []
        }
        self.capabilities = []
    
    def add_initiative(self, name, timeline, business_value, dependencies, resources):
        """Add initiative to roadmap"""
        initiative = {
            'name': name,
            'timeline': timeline,
            'business_value': business_value,
            'dependencies': dependencies,
            'resources': resources,
            'status': 'planned'
        }
        
        if timeline <= 6:
            self.initiatives['quick_wins'].append(initiative)
        elif timeline <= 12:
            self.initiatives['medium_term'].append(initiative)
        else:
            self.initiatives['long_term'].append(initiative)
    
    def add_capability(self, capability_name, current_level, target_level, timeline):
        """Add capability development goal"""
        capability = {
            'name': capability_name,
            'current_level': current_level,  # 1-5
            'target_level': target_level,  # 1-5
            'timeline': timeline,
            'gap': target_level - current_level
        }
        self.capabilities.append(capability)
    
    def generate_roadmap_summary(self):
        """Generate roadmap summary"""
        summary = f"""
# {self.company_name} Data Science Roadmap

## Quick Wins (0-6 months)
"""
        for init in self.initiatives['quick_wins']:
            summary += f"- **{init['name']}**: {init['business_value']}\n"
        
        summary += "\n## Medium-Term (6-12 months)\n"
        for init in self.initiatives['medium_term']:
            summary += f"- **{init['name']}**: {init['business_value']}\n"
        
        summary += "\n## Long-Term (12+ months)\n"
        for init in self.initiatives['long_term']:
            summary += f"- **{init['name']}**: {init['business_value']}\n"
        
        summary += "\n## Capability Development\n"
        for cap in sorted(self.capabilities, key=lambda x: x['gap'], reverse=True):
            summary += f"- **{cap['name']}**: Level {cap['current_level']} → {cap['target_level']} ({cap['timeline']} months)\n"
        
        return summary

# Example usage
roadmap = DataScienceRoadmap("TechCorp")

# Add quick wins
roadmap.add_initiative(
    name="Customer Churn Dashboard",
    timeline=3,
    business_value="Visibility into churn drivers, enable proactive retention",
    dependencies=[],
    resources="1 DS, 1 analyst"
)

# Add medium-term initiatives
roadmap.add_initiative(
    name="Personalization Engine",
    timeline=9,
    business_value="Increase conversion by 15%, improve user experience",
    dependencies=["Feature store", "A/B testing framework"],
    resources="2 DS, 1 MLE"
)

# Add long-term initiatives
roadmap.add_initiative(
    name="Real-time Recommendation System",
    timeline=18,
    business_value="Real-time personalization, competitive advantage",
    dependencies=["Streaming infrastructure", "Model serving platform"],
    resources="3 DS, 2 MLE, 1 DE"
)

# Add capabilities
roadmap.add_capability("MLOps Maturity", current_level=2, target_level=4, timeline=12)
roadmap.add_capability("Real-time ML", current_level=1, target_level=3, timeline=18)
roadmap.add_capability("NLP Capabilities", current_level=2, target_level=4, timeline=15)

print(roadmap.generate_roadmap_summary())

# FastAPI model serving example
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import numpy as np
import joblib
from typing import List, Dict
import redis
import hashlib
import json

app = FastAPI()

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

# Redis for caching
cache = redis.Redis(host='localhost', port=6379, decode_responses=True)

class PredictionRequest(BaseModel):
    features: List[float]
    user_id: str

class PredictionResponse(BaseModel):
    prediction: float
    confidence: float
    model_version: str

def generate_cache_key(features: List[float]) -> str:
    """Generate cache key from features"""
    feature_str = json.dumps(features, sort_keys=True)
    return hashlib.md5(feature_str.encode()).hexdigest()

@app.post("/predict", response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    try:
        # Check cache
        cache_key = generate_cache_key(request.features)
        cached_result = cache.get(cache_key)
        
        if cached_result:
            return json.loads(cached_result)
        
        # Make prediction
        features = np.array(request.features).reshape(1, -1)
        prediction = model.predict(features)[0]
        confidence = model.predict_proba(features).max()
        
        response = PredictionResponse(
            prediction=float(prediction),
            confidence=float(confidence),
            model_version="v1.2.3"
        )
        
        # Cache result (TTL: 1 hour)
        cache.setex(cache_key, 3600, response.json())
        
        return response
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
    return {"status": "healthy", "model_loaded": model is not None}

# Apache Beam pipeline for batch predictions
import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions
import tensorflow as tf

class LoadModel(beam.DoFn):
    def setup(self):
        self.model = tf.keras.models.load_model('gs://models/latest')
    
    def process(self, element):
        yield element

class MakePredictions(beam.DoFn):
    def setup(self):
        self.model = tf.keras.models.load_model('gs://models/latest')
    
    def process(self, batch):
        features = [item['features'] for item in batch]
        predictions = self.model.predict(np.array(features))
        
        for item, pred in zip(batch, predictions):
            yield {
                'id': item['id'],
                'prediction': float(pred[0]),
                'timestamp': datetime.now().isoformat()
            }

def run_batch_prediction_pipeline():
    options = PipelineOptions([
        '--runner=DataflowRunner',
        '--project=my-project',
        '--region=us-central1',
        '--temp_location=gs://temp/',
    ])
    
    with beam.Pipeline(options=options) as pipeline:
        predictions = (
            pipeline
            | 'Read from BigQuery' >> beam.io.ReadFromBigQuery(
                query='SELECT * FROM dataset.features WHERE date = CURRENT_DATE()'
            )
            | 'Batch elements' >> beam.BatchElements(min_batch_size=100, max_batch_size=1000)
            | 'Make predictions' >> beam.ParDo(MakePredictions())
            | 'Write to BigQuery' >> beam.io.WriteToBigQuery(
                'dataset.predictions',
                schema='id:STRING,prediction:FLOAT,timestamp:TIMESTAMP'
            )
        )

# Feast feature store integration
from feast import FeatureStore
import pandas as pd

class FeatureService:
    def __init__(self):
        self.store = FeatureStore(repo_path=".")
    
    def get_online_features(self, entity_ids: List[str]) -> pd.DataFrame:
        """Retrieve features for online prediction"""
        entity_df = pd.DataFrame({
            "user_id": entity_ids
        })
        
        features = self.store.get_online_features(
            features=[
                "user_features:age",
                "user_features:total_purchases",
                "user_features:avg_order_value",
                "user_activity:days_since_last_visit",
                "user_activity:page_views_7d"
            ],
            entity_rows=entity_df.to_dict('records')
        ).to_df()
        
        return features
    
    def get_historical_features(self, entity_df: pd.DataFrame) -> pd.DataFrame:
        """Retrieve features for training"""
        training_df = self.store.get_historical_features(
            entity_df=entity_df,
            features=[
                "user_features:age",
                "user_features:total_purchases",
                "user_activity:page_views_7d"
            ]
        ).to_df()
        
        return training_df

# Prometheus metrics for model monitoring
from prometheus_client import Counter, Histogram, Gauge
import time

# Define metrics
prediction_counter = Counter(
    'model_predictions_total',
    'Total number of predictions',
    ['model_version', 'status']
)

prediction_latency = Histogram(
    'model_prediction_latency_seconds',
    'Prediction latency in seconds',
    ['model_version']
)

prediction_confidence = Histogram(
    'model_prediction_confidence',
    'Prediction confidence scores',
    ['model_version'],
    buckets=[0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99, 1.0]
)

data_drift_score = Gauge(
    'model_data_drift_score',
    'Data drift score',
    ['feature_name']
)

class ModelMonitor:
    def __init__(self, model_version: str):
        self.model_version = model_version
    
    def track_prediction(self, confidence: float, latency: float, status: str):
        """Track prediction metrics"""
        prediction_counter.labels(
            model_version=self.model_version,
            status=status
        ).inc()
        
        prediction_latency.labels(
            model_version=self.model_version
        ).observe(latency)
        
        prediction_confidence.labels(
            model_version=self.model_version
        ).observe(confidence)
    
    def check_data_drift(self, reference_data: pd.DataFrame, current_data: pd.DataFrame):
        """Detect data drift using KS test"""
        from scipy.stats import ks_2samp
        
        for column in reference_data.columns:
            statistic, p_value = ks_2samp(
                reference_data[column],
                current_data[column]
            )
            
            data_drift_score.labels(feature_name=column).set(statistic)
            
            if p_value < 0.05:
                print(f"WARNING: Data drift detected in {column}")

# A/B testing for model deployment
class ModelABTest:
    def __init__(self, control_model, treatment_model, traffic_split=0.5):
        self.control_model = control_model
        self.treatment_model = treatment_model
        self.traffic_split = traffic_split
    
    def assign_variant(self, user_id: str) -> str:
        """Assign user to control or treatment"""
        hash_value = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
        return 'treatment' if (hash_value % 100) / 100 < self.traffic_split else 'control'
    
    def predict(self, user_id: str, features: np.ndarray):
        """Make prediction based on assigned variant"""
        variant = self.assign_variant(user_id)
        
        if variant == 'treatment':
            prediction = self.treatment_model.predict(features)
            model_version = 'treatment'
        else:
            prediction = self.control_model.predict(features)
            model_version = 'control'
        
        # Log for analysis
        self.log_prediction(user_id, variant, prediction)
        
        return prediction, model_version
    
    def analyze_results(self) -> Dict:
        """Analyze A/B test results"""
        # Query metrics from database
        control_metrics = self.get_metrics('control')
        treatment_metrics = self.get_metrics('treatment')
        
        # Statistical significance test
        from scipy.stats import ttest_ind
        
        statistic, p_value = ttest_ind(
            control_metrics['conversion_rate'],
            treatment_metrics['conversion_rate']
        )
        
        return {
            'control_mean': np.mean(control_metrics['conversion_rate']),
            'treatment_mean': np.mean(treatment_metrics['conversion_rate']),
            'lift': (np.mean(treatment_metrics['conversion_rate']) - 
                    np.mean(control_metrics['conversion_rate'])) / 
                    np.mean(control_metrics['conversion_rate']),
            'p_value': p_value,
            'significant': p_value < 0.05
        }

# ML Project Requirements Template
class MLProjectRequirements:
    def __init__(self):
        self.requirements = {
            'business_objective': '',
            'success_metrics': [],
            'constraints': {},
            'stakeholders': [],
            'timeline': {},
            'data_requirements': {},
            'technical_requirements': {}
        }
    
    def define_business_objective(self, objective: str, kpis: List[str]):
        """Define clear business objective"""
        self.requirements['business_objective'] = objective
        self.requirements['success_metrics'] = kpis
        
        # Example:
        # objective: "Reduce customer churn by 20%"
        # kpis: ["Churn rate", "Customer lifetime value", "Retention rate"]
    
    def define_constraints(self, latency_ms: int, accuracy_threshold: float, budget: float):
        """Define system constraints"""
        self.requirements['constraints'] = {
            'max_latency_ms': latency_ms,
            'min_accuracy': accuracy_threshold,
            'budget_usd': budget,
            'compliance': ['GDPR', 'CCPA'],
            'explainability': 'required'
        }
    
    def assess_feasibility(self) -> Dict:
        """Assess project feasibility"""
        return {
            'data_availability': self.check_data_availability(),
            'technical_feasibility': self.check_technical_feasibility(),
            'resource_requirements': self.estimate_resources(),
            'timeline_estimate': self.estimate_timeline(),
            'risks': self.identify_risks()
        }

# Churn Prediction Model - Stakeholder Brief

## For Product Team

### Business Impact
- **Goal:** Reduce churn from 15% to 12% (20% reduction)
- **Revenue Impact:** $2M annual savings
- **Timeline:** 3 months to production
- **Success Metrics:**
  - Churn rate reduction
  - Proactive retention campaign effectiveness
  - Customer satisfaction scores

### How It Works (Non-Technical)
The model analyzes customer behavior patterns (purchases, engagement, support tickets) 
to identify customers at risk of churning 3 months in advance. This gives the retention 
team time to intervene with targeted offers.

### What We Need From Product
- Access to customer feedback data
- Collaboration on retention campaign design
- A/B testing support
- User research on intervention strategies

## For Engineering Team

### Technical Specifications
- **Model Type:** Gradient Boosting Classifier
- **Input:** 45 features (user activity, transactions, support)
- **Output:** Churn probability (0-1) + risk factors
- **Latency:** <100ms (p95)
- **Throughput:** 1000 predictions/second
- **Model Size:** ~50MB

### Integration Requirements
```python
# API Endpoint
POST /api/v1/predict/churn
{
  "user_id": "12345",
  "features": {...}  # Optional, will fetch from feature store if not provided
}

# Response
{
  "churn_probability": 0.75,
  "risk_factors": ["low_engagement", "support_tickets"],
  "confidence": 0.85,
  "model_version": "v1.2.3"
}

class ExpectationManagement:
    def set_realistic_goals(self):
        """Set achievable goals with stakeholders"""
        return {
            'what_ml_can_do': [
                'Predict churn probability with 80% accuracy',
                'Identify top risk factors',
                'Prioritize intervention targets'
            ],
            'what_ml_cannot_do': [
                'Guarantee 100% accuracy',
                'Explain every prediction perfectly',
                'Prevent all churn'
            ],
            'timeline': {
                'poc': '2-3 weeks',
                'mvp': '6-8 weeks total',
                'production': '10-12 weeks total'
            },
            'ongoing_work': [
                'Model monitoring and maintenance',
                'Periodic retraining',
                'Performance optimization',
                'Feature engineering'
            ]
        }

class DataScientistRole:
    def __init__(self, level: str):
        self.level = level  # Junior, Mid, Senior, Staff
        self.requirements = self.define_requirements()
    
    def define_requirements(self) -> Dict:
        """Define role requirements by level"""
        requirements = {
            'Junior': {
                'technical_skills': [
                    'Python/R programming',
                    'SQL and data manipulation',
                    'Basic ML algorithms',
                    'Statistics fundamentals',
                    'Data visualization'
                ],
                'experience': '0-2 years',
                'education': 'BS in quantitative field',
                'soft_skills': [
                    'Curiosity and learning mindset',
                    'Communication',
                    'Collaboration'
                ]
            },
            'Mid': {
                'technical_skills': [
                    'Advanced ML techniques',
                    'Feature engineering',
                    'Model deployment basics',
                    'Experimental design',
                    'Deep learning fundamentals'
                ],
                'experience': '2-5 years',
                'education': 'BS/MS in quantitative field',
                'soft_skills': [
                    'Project ownership',
                    'Stakeholder communication',
                    'Mentoring juniors'
                ]
            },
            'Senior': {
                'technical_skills': [
                    'Advanced ML and DL',
                    'Production ML systems',
                    'MLOps and infrastructure',
                    'Research and innovation',
                    'Architecture design'
                ],
                'experience': '5+ years',
                'education': 'MS/PhD preferred',
                'soft_skills': [
                    'Technical leadership',
                    'Strategic thinking',
                    'Cross-functional collaboration',
                    'Mentorship'
                ]
            }
        }
        return requirements[self.level]

# Phone screen questions
phone_screen_questions = {
    'background': [
        "Walk me through your most impactful ML project",
        "What was your role and contribution?",
        "What challenges did you face and how did you overcome them?"
    ],
    'technical_basics': [
        "Explain bias-variance tradeoff",
        "When would you use random forest vs gradient boosting?",
        "How do you handle imbalanced datasets?"
    ],
    'problem_solving': [
        "How would you approach building a recommendation system?",
        "How would you detect fraudulent transactions?"
    ]
}

# Take-home assignment example
class TakeHomeAssignment:
    def __init__(self):
        self.dataset = "customer_churn.csv"
        self.time_limit = "4-6 hours"
    
    def requirements(self):
        return """
        # Customer Churn Prediction Assignment
        
        ## Dataset
        - 10,000 customer records
        - 20 features (demographics, usage, support)
        - Binary target (churned: yes/no)
        
        ## Tasks
        1. **Exploratory Data Analysis**
           - Analyze data quality
           - Identify patterns and insights
           - Visualize key relationships
        
        2. **Feature Engineering**
           - Create relevant features
           - Handle missing values
           - Encode categorical variables
        
        3. **Model Development**
           - Train at least 2 different models
           - Tune hyperparameters
           - Evaluate with appropriate metrics
        
        4. **Business Recommendations**
           - Interpret model results
           - Identify key churn drivers
           - Suggest retention strategies
        
        ## Deliverables
        - Jupyter notebook with code and analysis
        - Brief presentation (5 slides)
        - Model performance summary
        
        ## Evaluation Criteria
        - Code quality and organization
        - Analytical thinking
        - Communication of insights
        - Model performance
        - Business acumen
        """

technical_deep_dive = {
    'ml_fundamentals': [
        "Derive the gradient for logistic regression",
        "Explain how gradient boosting works",
        "Compare different regularization techniques"
    ],
    'system_design': [
        "Design a real-time recommendation system for 10M users",
        "How would you build a fraud detection system?",
        "Design an A/B testing framework"
    ],
    'coding': [
        "Implement k-means clustering from scratch",
        "Write a function to calculate precision-recall curve",
        "Optimize this slow data processing pipeline"
    ]
}

# Case Study: E-commerce Personalization

## Scenario
You're tasked with building a personalization engine for an e-commerce site 
with 1M products and 10M users.

## Questions
1. How would you approach this problem?
2. What data would you need?
3. What models would you consider?
4. How would you evaluate success?
5. What are the main challenges?
6. How would you deploy and monitor?

## Evaluation
- Problem decomposition
- Technical approach
- Trade-off analysis
- Business understanding
- Communication clarity

behavioral_questions = {
    'leadership': [
        "Tell me about a time you led a complex ML project",
        "How do you handle disagreements with stakeholders?",
        "Describe a time you had to make a difficult trade-off"
    ],
    'collaboration': [
        "How do you work with non-technical stakeholders?",
        "Tell me about a time you mentored someone",
        "Describe a cross-functional project you worked on"
    ],
    'growth_mindset': [
        "Tell me about a time you failed and what you learned",
        "How do you stay current with ML research?",
        "What's an area you're actively trying to improve?"
    ]
}

class CandidateEvaluation:
    def __init__(self):
        self.criteria = {
            'technical_skills': {
                'weight': 0.35,
                'subcriteria': {
                    'ml_knowledge': 0.4,
                    'coding_ability': 0.3,
                    'system_design': 0.3
                }
            },
            'problem_solving': {
                'weight': 0.25,
                'subcriteria': {
                    'analytical_thinking': 0.5,
                    'creativity': 0.3,
                    'pragmatism': 0.2
                }
            },
            'communication': {
                'weight': 0.20,
                'subcriteria': {
                    'clarity': 0.4,
                    'stakeholder_management': 0.4,
                    'documentation': 0.2
                }
            },
            'collaboration': {
                'weight': 0.15,
                'subcriteria': {
                    'teamwork': 0.5,
                    'mentorship': 0.3,
                    'culture_fit': 0.2
                }
            },
            'growth_potential': {
                'weight': 0.05,
                'subcriteria': {
                    'learning_mindset': 0.6,
                    'adaptability': 0.4
                }
            }
        }
    
    def calculate_score(self, ratings: Dict) -> float:
        """Calculate weighted score"""
        total_score = 0
        for criterion, details in self.criteria.items():
            criterion_score = 0
            for subcriterion, weight in details['subcriteria'].items():
                criterion_score += ratings[criterion][subcriterion] * weight
            total_score += criterion_score * details['weight']
        return total_score