🔥 Logistic Regression

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import make_classification, load_breast_cancer
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, classification_report, 
                           confusion_matrix, roc_curve, auc, 
                           precision_recall_curve)
from sklearn.preprocessing import StandardScaler
import warnings
warnings.filterwarnings('ignore')

# Binary Classification Example
print("=" * 50)
print("BINARY LOGISTIC REGRESSION")
print("=" * 50)

# Generate sample data
X, y = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=42
)

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Scale features (important for logistic regression)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Create and train model
log_reg = LogisticRegression(
    random_state=42,
    max_iter=1000,
    solver='lbfgs'  # Good for small datasets
)

log_reg.fit(X_train_scaled, y_train)

# Make predictions
y_pred = log_reg.predict(X_test_scaled)
y_pred_proba = log_reg.predict_proba(X_test_scaled)

# Evaluate model
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.3f}")
print(f"\nCoefficients: {log_reg.coef_[0]}")
print(f"Intercept: {log_reg.intercept_[0]:.3f}")

print("\nClassification Report:")
print(classification_report(y_test, y_pred))

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(12, 4))

plt.subplot(1, 3, 1)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')

# ROC Curve
fpr, tpr, _ = roc_curve(y_test, y_pred_proba[:, 1])
roc_auc = auc(fpr, tpr)

plt.subplot(1, 3, 2)
plt.plot(fpr, tpr, color='darkorange', lw=2, 
         label=f'ROC curve (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc="lower right")

# Decision boundary visualization
plt.subplot(1, 3, 3)
h = 0.02
x_min, x_max = X_train_scaled[:, 0].min() - 1, X_train_scaled[:, 0].max() + 1
y_min, y_max = X_train_scaled[:, 1].min() - 1, X_train_scaled[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

Z = log_reg.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, levels=50, alpha=0.8, cmap='RdYlBu')
plt.scatter(X_train_scaled[:, 0], X_train_scaled[:, 1], 
           c=y_train, cmap='RdYlBu', edgecolors='black')
plt.title('Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')

plt.tight_layout()
plt.show()

# Real-world example: Breast Cancer Dataset
print("\n" + "=" * 50)
print("REAL-WORLD EXAMPLE: BREAST CANCER CLASSIFICATION")
print("=" * 50)

# Load dataset
cancer = load_breast_cancer()
X_cancer = cancer.data
y_cancer = cancer.target

# Use subset of features for interpretability
feature_names = cancer.feature_names[:10]  # First 10 features
X_cancer_subset = X_cancer[:, :10]

print(f"Dataset shape: {X_cancer_subset.shape}")
print(f"Features: {list(feature_names)}")
print(f"Classes: {cancer.target_names}")

# Split and scale
X_train_cancer, X_test_cancer, y_train_cancer, y_test_cancer = train_test_split(
    X_cancer_subset, y_cancer, test_size=0.2, random_state=42, stratify=y_cancer
)

scaler_cancer = StandardScaler()
X_train_cancer_scaled = scaler_cancer.fit_transform(X_train_cancer)
X_test_cancer_scaled = scaler_cancer.transform(X_test_cancer)

# Train model
cancer_model = LogisticRegression(random_state=42, max_iter=1000)
cancer_model.fit(X_train_cancer_scaled, y_train_cancer)

# Predictions
y_pred_cancer = cancer_model.predict(X_test_cancer_scaled)
y_pred_proba_cancer = cancer_model.predict_proba(X_test_cancer_scaled)

print(f"Cancer Classification Accuracy: {accuracy_score(y_test_cancer, y_pred_cancer):.3f}")

# Feature importance (coefficients)
feature_importance = pd.DataFrame({
    'Feature': feature_names,
    'Coefficient': cancer_model.coef_[0],
    'Abs_Coefficient': np.abs(cancer_model.coef_[0])
}).sort_values('Abs_Coefficient', ascending=False)

print("\nFeature Importance (by coefficient magnitude):")
print(feature_importance)

# Multiclass Classification Example
print("\n" + "=" * 50)
print("MULTICLASS LOGISTIC REGRESSION")
print("=" * 50)

from sklearn.datasets import make_classification

# Generate multiclass data
X_multi, y_multi = make_classification(
    n_samples=1000,
    n_features=4,
    n_informative=3,
    n_redundant=1,
    n_classes=3,
    n_clusters_per_class=1,
    random_state=42
)

X_train_multi, X_test_multi, y_train_multi, y_test_multi = train_test_split(
    X_multi, y_multi, test_size=0.2, random_state=42, stratify=y_multi
)

scaler_multi = StandardScaler()
X_train_multi_scaled = scaler_multi.fit_transform(X_train_multi)
X_test_multi_scaled = scaler_multi.transform(X_test_multi)

# Train multiclass model
multi_model = LogisticRegression(
    multi_class='ovr',  # One-vs-Rest
    random_state=42,
    max_iter=1000
)

multi_model.fit(X_train_multi_scaled, y_train_multi)

# Evaluate
y_pred_multi = multi_model.predict(X_test_multi_scaled)
print(f"Multiclass Accuracy: {accuracy_score(y_test_multi, y_pred_multi):.3f}")
print("\nMulticlass Classification Report:")
print(classification_report(y_test_multi, y_pred_multi))

# Cross-validation
cv_scores = cross_val_score(multi_model, X_train_multi_scaled, y_train_multi, cv=5)
print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {cv_scores.mean():.3f} (+/- {cv_scores.std() * 2:.3f})")

from sklearn.model_selection import GridSearchCV

# Define parameter grid
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],  # Regularization strength
    'penalty': ['l1', 'l2'],        # Regularization type
    'solver': ['liblinear', 'saga'] # Solvers that support both L1 and L2
}

# Grid search
grid_search = GridSearchCV(
    LogisticRegression(random_state=42, max_iter=1000),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X_train_scaled, y_train)

print("Best parameters:", grid_search.best_params_)
print("Best cross-validation score:", grid_search.best_score_)

# Use best model
best_model = grid_search.best_estimator_
best_pred = best_model.predict(X_test_scaled)
print("Best model test accuracy:", accuracy_score(y_test, best_pred))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

class LogisticRegressionFromScratch:
    """Logistic Regression implementation from scratch"""

    def __init__(self, learning_rate=0.01, max_iterations=1000, fit_intercept=True, verbose=False):
        self.learning_rate = learning_rate
        self.max_iterations = max_iterations
        self.fit_intercept = fit_intercept
        self.verbose = verbose

    def _add_intercept(self, X):
        """Add bias column to the feature matrix"""
        intercept = np.ones((X.shape[0], 1))
        return np.concatenate((intercept, X), axis=1)

    def _sigmoid(self, z):
        """Sigmoid activation function"""
        # Clip z to prevent overflow
        z = np.clip(z, -500, 500)
        return 1 / (1 + np.exp(-z))

    def _cost_function(self, h, y):
        """Calculate the logistic regression cost function"""
        # Avoid log(0) by adding small epsilon
        epsilon = 1e-15
        h = np.clip(h, epsilon, 1 - epsilon)
        return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()

    def fit(self, X, y):
        """Train the logistic regression model"""
        # Add intercept term if needed
        if self.fit_intercept:
            X = self._add_intercept(X)

        # Initialize weights
        self.weights = np.zeros(X.shape[1])

        # Store cost history
        self.cost_history = []

        # Gradient descent
        for i in range(self.max_iterations):
            # Forward propagation
            z = np.dot(X, self.weights)
            h = self._sigmoid(z)

            # Calculate cost
            cost = self._cost_function(h, y)
            self.cost_history.append(cost)

            # Calculate gradient
            gradient = np.dot(X.T, (h - y)) / y.size

            # Update weights
            self.weights -= self.learning_rate * gradient

            # Print progress
            if self.verbose and i % 100 == 0:
                print(f"Iteration {i}: Cost = {cost:.6f}")

    def predict_proba(self, X):
        """Predict probabilities"""
        if self.fit_intercept:
            X = self._add_intercept(X)

        probabilities = self._sigmoid(np.dot(X, self.weights))
        return np.vstack([1 - probabilities, probabilities]).T

    def predict(self, X):
        """Make predictions"""
        return (self.predict_proba(X)[:, 1] >= 0.5).astype(int)

    def score(self, X, y):
        """Calculate accuracy"""
        return (self.predict(X) == y).mean()

# Example usage of from-scratch implementation
print("=" * 60)
print("FROM SCRATCH IMPLEMENTATION")
print("=" * 60)

# Generate sample data
np.random.seed(42)
X_scratch, y_scratch = make_classification(
    n_samples=1000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    random_state=42
)

# Split and scale data
X_train_scratch, X_test_scratch, y_train_scratch, y_test_scratch = train_test_split(
    X_scratch, y_scratch, test_size=0.2, random_state=42
)

scaler_scratch = StandardScaler()
X_train_scratch_scaled = scaler_scratch.fit_transform(X_train_scratch)
X_test_scratch_scaled = scaler_scratch.transform(X_test_scratch)

# Train custom logistic regression
custom_lr = LogisticRegressionFromScratch(
    learning_rate=0.01,
    max_iterations=1000,
    verbose=True
)

custom_lr.fit(X_train_scratch_scaled, y_train_scratch)

# Make predictions
y_pred_scratch = custom_lr.predict(X_test_scratch_scaled)
y_pred_proba_scratch = custom_lr.predict_proba(X_test_scratch_scaled)

custom_accuracy = custom_lr.score(X_test_scratch_scaled, y_test_scratch)
print(f"\nCustom Logistic Regression Accuracy: {custom_accuracy:.3f}")
print(f"Final weights: {custom_lr.weights}")

# Compare with sklearn
sklearn_lr = LogisticRegression(random_state=42, max_iter=1000)
sklearn_lr.fit(X_train_scratch_scaled, y_train_scratch)
sklearn_pred = sklearn_lr.predict(X_test_scratch_scaled)
sklearn_accuracy = accuracy_score(y_test_scratch, sklearn_pred)

print(f"Scikit-learn Accuracy: {sklearn_accuracy:.3f}")
print(f"Accuracy difference: {abs(custom_accuracy - sklearn_accuracy):.4f}")

# Plot cost function
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(custom_lr.cost_history)
plt.title('Cost Function During Training')
plt.xlabel('Iteration')
plt.ylabel('Cost')
plt.grid(True)

# Visualize decision boundary
plt.subplot(1, 2, 2)
h = 0.02
x_min, x_max = X_train_scratch_scaled[:, 0].min() - 1, X_train_scratch_scaled[:, 0].max() + 1
y_min, y_max = X_train_scratch_scaled[:, 1].min() - 1, X_train_scratch_scaled[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

Z = custom_lr.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, levels=50, alpha=0.8, cmap='RdYlBu')
plt.scatter(X_train_scratch_scaled[:, 0], X_train_scratch_scaled[:, 1], 
           c=y_train_scratch, cmap='RdYlBu', edgecolors='black')
plt.title('Custom Implementation Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')

plt.tight_layout()
plt.show()

# Advanced from-scratch implementation with regularization
class RegularizedLogisticRegression:
    """Logistic Regression with L1 and L2 regularization"""

    def __init__(self, learning_rate=0.01, max_iterations=1000, 
                 regularization=None, lambda_reg=0.01, fit_intercept=True):
        self.learning_rate = learning_rate
        self.max_iterations = max_iterations
        self.regularization = regularization  # 'l1', 'l2', or None
        self.lambda_reg = lambda_reg
        self.fit_intercept = fit_intercept

    def _add_intercept(self, X):
        intercept = np.ones((X.shape[0], 1))
        return np.concatenate((intercept, X), axis=1)

    def _sigmoid(self, z):
        z = np.clip(z, -500, 500)
        return 1 / (1 + np.exp(-z))

    def _cost_function(self, h, y):
        epsilon = 1e-15
        h = np.clip(h, epsilon, 1 - epsilon)
        cost = (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()

        # Add regularization term
        if self.regularization == 'l1':
            # Don't regularize intercept term
            reg_term = self.lambda_reg * np.sum(np.abs(self.weights[1:]))
        elif self.regularization == 'l2':
            reg_term = self.lambda_reg * np.sum(self.weights[1:] ** 2)
        else:
            reg_term = 0

        return cost + reg_term

    def fit(self, X, y):
        if self.fit_intercept:
            X = self._add_intercept(X)

        self.weights = np.zeros(X.shape[1])
        self.cost_history = []

        for i in range(self.max_iterations):
            # Forward propagation
            z = np.dot(X, self.weights)
            h = self._sigmoid(z)

            # Calculate cost
            cost = self._cost_function(h, y)
            self.cost_history.append(cost)

            # Calculate gradient
            gradient = np.dot(X.T, (h - y)) / y.size

            # Add regularization to gradient
            if self.regularization == 'l1':
                gradient[1:] += self.lambda_reg * np.sign(self.weights[1:])
            elif self.regularization == 'l2':
                gradient[1:] += 2 * self.lambda_reg * self.weights[1:]

            # Update weights
            self.weights -= self.learning_rate * gradient

    def predict_proba(self, X):
        if self.fit_intercept:
            X = self._add_intercept(X)
        probabilities = self._sigmoid(np.dot(X, self.weights))
        return np.vstack([1 - probabilities, probabilities]).T

    def predict(self, X):
        return (self.predict_proba(X)[:, 1] >= 0.5).astype(int)

# Test regularized implementation
print("\n" + "=" * 60)
print("REGULARIZED IMPLEMENTATION")
print("=" * 60)

# Test L1 regularization
l1_model = RegularizedLogisticRegression(
    learning_rate=0.01,
    max_iterations=1000,
    regularization='l1',
    lambda_reg=0.01
)

l1_model.fit(X_train_scratch_scaled, y_train_scratch)
l1_accuracy = l1_model.score(X_test_scratch_scaled, y_test_scratch)

# Test L2 regularization
l2_model = RegularizedLogisticRegression(
    learning_rate=0.01,
    max_iterations=1000,
    regularization='l2',
    lambda_reg=0.01
)

l2_model.fit(X_train_scratch_scaled, y_train_scratch)
l2_accuracy = l2_model.score(X_test_scratch_scaled, y_test_scratch)

print(f"L1 Regularized Accuracy: {l1_accuracy:.3f}")
print(f"L2 Regularized Accuracy: {l2_accuracy:.3f}")
print(f"No Regularization Accuracy: {custom_accuracy:.3f}")

print(f"\nL1 weights: {l1_model.weights}")
print(f"L2 weights: {l2_model.weights}")
print(f"No reg weights: {custom_lr.weights}")

# Customer churn prediction using logistic regression
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.metrics import accuracy_score, classification_report, roc_curve, auc

# Simulate customer churn data
np.random.seed(42)
n_customers = 2000

# Generate synthetic customer data
data = {
    'age': np.random.normal(40, 12, n_customers).astype(int),
    'tenure_months': np.random.exponential(24, n_customers).astype(int),
    'monthly_charges': np.random.normal(65, 20, n_customers),
    'total_charges': np.random.normal(1500, 800, n_customers),
    'contract_type': np.random.choice(['Month-to-month', 'One year', 'Two year'], 
                                     n_customers, p=[0.5, 0.3, 0.2]),
    'payment_method': np.random.choice(['Electronic check', 'Mailed check', 'Bank transfer', 'Credit card'],
                                      n_customers, p=[0.4, 0.2, 0.2, 0.2]),
    'customer_service_calls': np.random.poisson(2, n_customers),
    'internet_service': np.random.choice(['DSL', 'Fiber optic', 'No'], 
                                        n_customers, p=[0.4, 0.4, 0.2])
}

# Create churn based on logical rules (with noise)
churn_probability = (
    (data['contract_type'] == 'Month-to-month') * 0.3 +
    (data['customer_service_calls'] > 3) * 0.2 +
    (data['monthly_charges'] > 80) * 0.15 +
    (data['tenure_months'] < 12) * 0.25 +
    np.random.normal(0, 0.1, n_customers)  # Add noise
)

churn = (churn_probability > 0.5).astype(int)

# Create DataFrame
df_churn = pd.DataFrame(data)
df_churn['churn'] = churn

print("Customer Churn Dataset:")
print(df_churn.head())
print(f"\nChurn rate: {df_churn['churn'].mean():.2%}")
print(f"Dataset shape: {df_churn.shape}")

# Exploratory Data Analysis
fig, axes = plt.subplots(2, 3, figsize=(15, 10))

# Numerical features
numerical_features = ['age', 'tenure_months', 'monthly_charges', 'total_charges']
for i, feature in enumerate(numerical_features):
    ax = axes[i//3, i%3]
    df_churn.boxplot(column=feature, by='churn', ax=ax)
    ax.set_title(f'{feature} by Churn Status')
    ax.set_xlabel('Churn (0=No, 1=Yes)')

# Categorical features
df_churn['contract_type'].value_counts().plot(kind='bar', ax=axes[1, 2])
axes[1, 2].set_title('Contract Type Distribution')
axes[1, 2].set_xlabel('Contract Type')

# Customer service calls vs churn
churn_by_calls = df_churn.groupby('customer_service_calls')['churn'].mean()
axes[1, 1].bar(churn_by_calls.index, churn_by_calls.values)
axes[1, 1].set_title('Churn Rate by Customer Service Calls')
axes[1, 1].set_xlabel('Number of Calls')
axes[1, 1].set_ylabel('Churn Rate')

plt.tight_layout()
plt.show()

# Data preprocessing
# Encode categorical variables
le_contract = LabelEncoder()
le_payment = LabelEncoder()
le_internet = LabelEncoder()

df_processed = df_churn.copy()
df_processed['contract_type_encoded'] = le_contract.fit_transform(df_churn['contract_type'])
df_processed['payment_method_encoded'] = le_payment.fit_transform(df_churn['payment_method'])
df_processed['internet_service_encoded'] = le_internet.fit_transform(df_churn['internet_service'])

# Select features for modeling
feature_columns = ['age', 'tenure_months', 'monthly_charges', 'total_charges',
                  'contract_type_encoded', 'payment_method_encoded', 
                  'customer_service_calls', 'internet_service_encoded']

X = df_processed[feature_columns]
y = df_processed['churn']

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train logistic regression model
churn_model = LogisticRegression(
    random_state=42,
    class_weight='balanced',  # Handle class imbalance
    max_iter=1000
)

churn_model.fit(X_train_scaled, y_train)

# Make predictions
y_pred = churn_model.predict(X_test_scaled)
y_pred_proba = churn_model.predict_proba(X_test_scaled)[:, 1]

# Evaluate model
print("\n" + "="*50)
print("CHURN PREDICTION RESULTS")
print("="*50)

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.3f}")

print("\nClassification Report:")
print(classification_report(y_test, y_pred, 
                          target_names=['No Churn', 'Churn']))

# Feature importance analysis
feature_importance = pd.DataFrame({
    'Feature': feature_columns,
    'Coefficient': churn_model.coef_[0],
    'Abs_Coefficient': np.abs(churn_model.coef_[0]),
    'Odds_Ratio': np.exp(churn_model.coef_[0])
}).sort_values('Abs_Coefficient', ascending=False)

print("\nFeature Importance:")
print(feature_importance)

# Interpret results
print("\nBusiness Insights:")
for _, row in feature_importance.head(3).iterrows():
    feature = row['Feature']
    coef = row['Coefficient']
    odds_ratio = row['Odds_Ratio']

    if coef > 0:
        impact = "increases"
    else:
        impact = "decreases"

    print(f"- {feature}: {impact} churn odds by {abs(odds_ratio-1)*100:.1f}%")

# ROC Curve
fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(fpr, tpr, color='darkorange', lw=2, 
         label=f'ROC curve (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Customer Churn - ROC Curve')
plt.legend(loc="lower right")

# Feature importance visualization
plt.subplot(1, 2, 2)
top_features = feature_importance.head(6)
colors = ['red' if x < 0 else 'green' for x in top_features['Coefficient']]
plt.barh(range(len(top_features)), top_features['Coefficient'], color=colors)
plt.yticks(range(len(top_features)), top_features['Feature'])
plt.xlabel('Coefficient Value')
plt.title('Feature Importance (Logistic Regression Coefficients)')
plt.axvline(x=0, color='black', linestyle='-', alpha=0.3)

plt.tight_layout()
plt.show()

# Customer segments analysis
print("\n" + "="*50)
print("CUSTOMER SEGMENTATION ANALYSIS")
print("="*50)

# Predict churn for different customer segments
segments = {
    'New Month-to-month': {
        'age': 35, 'tenure_months': 3, 'monthly_charges': 70, 
        'total_charges': 210, 'contract_type_encoded': le_contract.transform(['Month-to-month'])[0],
        'payment_method_encoded': le_payment.transform(['Electronic check'])[0],
        'customer_service_calls': 5, 'internet_service_encoded': le_internet.transform(['Fiber optic'])[0]
    },
    'Loyal Two-year': {
        'age': 45, 'tenure_months': 36, 'monthly_charges': 60,
        'total_charges': 2160, 'contract_type_encoded': le_contract.transform(['Two year'])[0],
        'payment_method_encoded': le_payment.transform(['Bank transfer'])[0],
        'customer_service_calls': 1, 'internet_service_encoded': le_internet.transform(['DSL'])[0]
    }
}

for segment_name, segment_data in segments.items():
    segment_features = np.array([[segment_data[col] for col in feature_columns]])
    segment_scaled = scaler.transform(segment_features)
    churn_prob = churn_model.predict_proba(segment_scaled)[0, 1]

    print(f"{segment_name} customer:")
    print(f"  Churn probability: {churn_prob:.1%}")
    print(f"  Risk level: {'High' if churn_prob > 0.7 else 'Medium' if churn_prob > 0.3 else 'Low'}")
    print()

# Medical diagnosis using logistic regression
from sklearn.datasets import load_breast_cancer
import pandas as pd
import numpy as np

print("="*60)
print("MEDICAL DIAGNOSIS: BREAST CANCER CLASSIFICATION")
print("="*60)

# Load breast cancer dataset
cancer = load_breast_cancer()
X_medical = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y_medical = cancer.target

print(f"Dataset Information:")
print(f"- Samples: {len(X_medical)}")
print(f"- Features: {len(cancer.feature_names)}")
print(f"- Classes: {cancer.target_names}")
print(f"- Class distribution: {np.bincount(y_medical)}")

# Focus on most clinically relevant features
clinical_features = [
    'mean radius', 'mean texture', 'mean perimeter', 'mean area',
    'mean compactness', 'mean concavity', 'mean concave points',
    'worst radius', 'worst perimeter', 'worst area'
]

X_clinical = X_medical[clinical_features]

# Split data
X_train_med, X_test_med, y_train_med, y_test_med = train_test_split(
    X_clinical, y_medical, test_size=0.2, random_state=42, stratify=y_medical
)

# Scale features
scaler_med = StandardScaler()
X_train_med_scaled = scaler_med.fit_transform(X_train_med)
X_test_med_scaled = scaler_med.transform(X_test_med)

# Train medical diagnosis model
medical_model = LogisticRegression(
    random_state=42,
    max_iter=1000,
    C=1.0  # No strong regularization for medical application
)

medical_model.fit(X_train_med_scaled, y_train_med)

# Predictions
y_pred_med = medical_model.predict(X_test_med_scaled)
y_pred_proba_med = medical_model.predict_proba(X_test_med_scaled)

print(f"\nDiagnostic Model Performance:")
print(f"Accuracy: {accuracy_score(y_test_med, y_pred_med):.3f}")

# Medical-specific metrics
from sklearn.metrics import confusion_matrix, precision_score, recall_score

cm_med = confusion_matrix(y_test_med, y_pred_med)
tn, fp, fn, tp = cm_med.ravel()

# Medical terminology
sensitivity = recall_score(y_test_med, y_pred_med)  # True Positive Rate
specificity = tn / (tn + fp)  # True Negative Rate
ppv = precision_score(y_test_med, y_pred_med)  # Positive Predictive Value
npv = tn / (tn + fn)  # Negative Predictive Value

print(f"\nMedical Performance Metrics:")
print(f"Sensitivity (Recall): {sensitivity:.3f}")
print(f"Specificity: {specificity:.3f}")
print(f"Positive Predictive Value: {ppv:.3f}")
print(f"Negative Predictive Value: {npv:.3f}")

print(f"\nConfusion Matrix:")
print(f"                 Predicted")
print(f"               Benign  Malignant")
print(f"Actual Benign    {tn:2d}      {fp:2d}")
print(f"    Malignant    {fn:2d}      {tp:2d}")

# Clinical interpretation of features
feature_clinical = pd.DataFrame({
    'Clinical_Feature': clinical_features,
    'Coefficient': medical_model.coef_[0],
    'Odds_Ratio': np.exp(medical_model.coef_[0]),
    'Clinical_Impact': ['Increases malignancy risk' if c > 0 else 'Decreases malignancy risk' 
                       for c in medical_model.coef_[0]]
}).sort_values('Coefficient', key=abs, ascending=False)

print(f"\nClinical Feature Analysis:")
print(feature_clinical)

# Risk stratification
risk_thresholds = [0.3, 0.7]
risk_levels = []

for prob in y_pred_proba_med[:, 1]:
    if prob < risk_thresholds[0]:
        risk_levels.append('Low Risk')
    elif prob < risk_thresholds[1]:
        risk_levels.append('Moderate Risk')
    else:
        risk_levels.append('High Risk')

risk_df = pd.DataFrame({
    'Patient_ID': range(len(y_test_med)),
    'Actual': ['Malignant' if y == 1 else 'Benign' for y in y_test_med],
    'Predicted_Probability': y_pred_proba_med[:, 1],
    'Risk_Level': risk_levels
})

print(f"\nRisk Stratification Summary:")
print(risk_df['Risk_Level'].value_counts())

# Show some example cases
print(f"\nExample High-Risk Cases:")
high_risk_cases = risk_df[risk_df['Risk_Level'] == 'High Risk'].head(3)
for _, case in high_risk_cases.iterrows():
    print(f"Patient {case['Patient_ID']}: {case['Predicted_Probability']:.1%} malignancy risk "
          f"(Actual: {case['Actual']})")