Scikit-learn

graph TD
    A[Scikit-learn] --> B[Core Components]
    A --> C[Data Handling]
    A --> D[Model Types]
    A --> E[Utilities]

    B --> B1[Estimators]
    B --> B2[Transformers]
    B --> B3[Predictors]
    B --> B4[Model Selection]
    B --> B5[Metrics]

    C --> C1[Datasets]
    C --> C2[Preprocessing]
    C --> C3[Feature Extraction]
    C --> C4[Feature Selection]

    D --> D1[Supervised Learning]
    D --> D2[Unsupervised Learning]
    D --> D3[Semi-supervised Learning]
    D --> D4[Model Ensembles]

    E --> E1[Pipelines]
    E --> E2[Cross-validation]
    E --> E3[Hyperparameter Tuning]
    E --> E4[Model Persistence]

    style A fill:#4CAF50,stroke:#333
    style B fill:#2196F3,stroke:#333
    style C fill:#FFC107,stroke:#333
    style D fill:#9C27B0,stroke:#333
    style E fill:#FF5722,stroke:#333

# Basic Scikit-learn workflow example
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# 1. Load dataset
print("Loading Iris dataset...")
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names

print(f"Dataset shape: {X.shape}")
print(f"Features: {feature_names}")
print(f"Target classes: {target_names}")

# 2. Split data into training and test sets
print("\nSplitting data into training and test sets...")
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

print(f"Training set size: {X_train.shape[0]}")
print(f"Test set size: {X_test.shape[0]}")

# 3. Preprocess data
print("\nPreprocessing data...")
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Train a model
print("\nTraining Logistic Regression model...")
model = LogisticRegression(max_iter=200, random_state=42)
model.fit(X_train_scaled, y_train)

# 5. Make predictions
print("\nMaking predictions...")
y_pred = model.predict(X_test_scaled)
y_pred_proba = model.predict_proba(X_test_scaled)

# 6. Evaluate the model
print("\nEvaluating model performance...")
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=target_names))

print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))

# 7. Feature importance
print("\nFeature importance:")
for i, feature in enumerate(feature_names):
    print(f"{feature}: {model.coef_[0][i]:.4f}")

# 8. Visualize decision boundaries (for first two features)
print("\nVisualizing decision boundaries...")
plt.figure(figsize=(12, 5))

# Plot decision boundaries
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, 0.02),
                     np.arange(y_min, y_max, 0.02))

Z = model.predict(np.c_[xx.ravel(), yy.ravel(),
                        np.zeros(xx.ravel().shape[0]),
                        np.zeros(xx.ravel().shape[0])])
Z = Z.reshape(xx.shape)

plt.subplot(1, 2, 1)
plt.contourf(xx, yy, Z, alpha=0.8, cmap=plt.cm.Paired)
plt.scatter(X_train_scaled[:, 0], X_train_scaled[:, 1], c=y_train,
            edgecolors='k', cmap=plt.cm.Paired)
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.title('Decision Boundaries (Training Set)')

# Plot test set predictions
plt.subplot(1, 2, 2)
plt.contourf(xx, yy, Z, alpha=0.8, cmap=plt.cm.Paired)
plt.scatter(X_test_scaled[:, 0], X_test_scaled[:, 1], c=y_pred,
            edgecolors='k', cmap=plt.cm.Paired, marker='s')
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.title('Predictions (Test Set)')

plt.tight_layout()
plt.show()

# Supervised learning examples
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier

print("\nSupervised Learning Examples...")

# Define models
models = {
    "Logistic Regression": LogisticRegression(max_iter=200, random_state=42),
    "Random Forest": RandomForestClassifier(n_estimators=100, random_state=42),
    "SVM": SVC(kernel='rbf', probability=True, random_state=42),
    "k-NN": KNeighborsClassifier(n_neighbors=5),
    "Naive Bayes": GaussianNB(),
    "Decision Tree": DecisionTreeClassifier(random_state=42)
}

# Train and evaluate each model
results = {}
for name, model in models.items():
    print(f"\nTraining {name}...")
    model.fit(X_train_scaled, y_train)
    y_pred = model.predict(X_test_scaled)
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = accuracy
    print(f"{name} Accuracy: {accuracy:.4f}")

# Display results
print("\nModel Comparison:")
for name, accuracy in sorted(results.items(), key=lambda x: x[1], reverse=True):
    print(f"{name}: {accuracy:.4f}")

# Unsupervised learning examples
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE

print("\nUnsupervised Learning Examples...")

# 1. Clustering with K-Means
print("\nK-Means Clustering...")
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
kmeans.fit(X_train_scaled)
kmeans_labels = kmeans.predict(X_test_scaled)

print("K-Means Cluster Centers:")
print(kmeans.cluster_centers_)

# 2. Dimensionality Reduction with PCA
print("\nPCA Dimensionality Reduction...")
pca = PCA(n_components=2)
X_train_pca = pca.fit_transform(X_train_scaled)
X_test_pca = pca.transform(X_test_scaled)

print("Explained variance ratio:")
print(pca.explained_variance_ratio_)

# 3. Visualize PCA results
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(X_train_pca[:, 0], X_train_pca[:, 1], c=y_train, cmap=plt.cm.Paired)
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.title('PCA of Iris Dataset (Training Set)')

plt.subplot(1, 2, 2)
plt.scatter(X_test_pca[:, 0], X_test_pca[:, 1], c=y_test, cmap=plt.cm.Paired)
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.title('PCA of Iris Dataset (Test Set)')

plt.tight_layout()
plt.show()

# 4. t-SNE for visualization
print("\nt-SNE Visualization...")
tsne = TSNE(n_components=2, random_state=42)
X_train_tsne = tsne.fit_transform(X_train_scaled)

plt.figure(figsize=(6, 5))
plt.scatter(X_train_tsne[:, 0], X_train_tsne[:, 1], c=y_train, cmap=plt.cm.Paired)
plt.xlabel('t-SNE Component 1')
plt.ylabel('t-SNE Component 2')
plt.title('t-SNE of Iris Dataset')
plt.colorbar()
plt.show()

# Model selection and evaluation examples
from sklearn.model_selection import cross_val_score, GridSearchCV, RandomizedSearchCV
from sklearn.metrics import roc_curve, auc, precision_recall_curve
from sklearn.preprocessing import label_binarize

print("\nModel Selection and Evaluation...")

# 1. Cross-validation
print("\nCross-validation...")
cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5)
print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV accuracy: {cv_scores.mean():.4f} (±{cv_scores.std():.4f})")

# 2. Hyperparameter tuning with GridSearchCV
print("\nHyperparameter tuning with GridSearchCV...")
param_grid = {
    'C': [0.1, 1, 10, 100],
    'penalty': ['l1', 'l2'],
    'solver': ['liblinear']
}

grid_search = GridSearchCV(
    LogisticRegression(max_iter=200, random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)

grid_search.fit(X_train_scaled, y_train)
print(f"Best parameters: {grid_search.best_params_}")
print(f"Best CV accuracy: {grid_search.best_score_:.4f}")

# 3. Hyperparameter tuning with RandomizedSearchCV
print("\nHyperparameter tuning with RandomizedSearchCV...")
param_dist = {
    'C': np.logspace(-3, 3, 100),
    'penalty': ['l1', 'l2'],
    'solver': ['liblinear', 'saga']
}

random_search = RandomizedSearchCV(
    LogisticRegression(max_iter=200, random_state=42),
    param_dist,
    n_iter=20,
    cv=5,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1
)

random_search.fit(X_train_scaled, y_train)
print(f"Best parameters: {random_search.best_params_}")
print(f"Best CV accuracy: {random_search.best_score_:.4f}")

# 4. ROC Curve and AUC (for binary classification - using one-vs-rest)
print("\nROC Curve and AUC...")
y_test_bin = label_binarize(y_test, classes=[0, 1, 2])
n_classes = y_test_bin.shape[1]

# Train model with best parameters
best_model = grid_search.best_estimator_
y_score = best_model.predict_proba(X_test_scaled)

# Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()

for i in range(n_classes):
    fpr[i], tpr[i], _ = roc_curve(y_test_bin[:, i], y_score[:, i])
    roc_auc[i] = auc(fpr[i], tpr[i])

# Plot ROC curves
plt.figure(figsize=(8, 6))
colors = ['blue', 'red', 'green']
for i, color in zip(range(n_classes), colors):
    plt.plot(fpr[i], tpr[i], color=color, lw=2,
             label=f'ROC curve of class {target_names[i]} (area = {roc_auc[i]:.2f})')

plt.plot([0, 1], [0, 1], 'k--', lw=2)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Multi-class ROC Curve')
plt.legend(loc="lower right")
plt.show()

# Pipelines and feature engineering examples
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.decomposition import TruncatedSVD

print("\nPipelines and Feature Engineering...")

# Create a pipeline with multiple steps
print("\nCreating machine learning pipeline...")

# Define preprocessing for numeric features
numeric_features = [0, 1, 2, 3]  # All features in iris dataset are numeric
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# Define feature selection
feature_selection = SelectKBest(score_func=f_classif, k=2)

# Define dimensionality reduction
dimensionality_reduction = TruncatedSVD(n_components=2)

# Create full pipeline
pipeline = Pipeline(steps=[
    ('preprocessor', numeric_transformer),
    ('feature_selection', feature_selection),
    ('dimensionality_reduction', dimensionality_reduction),
    ('classifier', LogisticRegression(max_iter=200, random_state=42))
])

# Train pipeline
print("Training pipeline...")
pipeline.fit(X_train, y_train)

# Evaluate pipeline
print("Evaluating pipeline...")
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Pipeline accuracy: {accuracy:.4f}")

# Get feature selection scores
print("\nFeature selection scores:")
feature_scores = pipeline.named_steps['feature_selection'].scores_
for i, score in enumerate(feature_scores):
    print(f"{feature_names[i]}: {score:.4f}")

# Get selected features
print("\nSelected features:")
selected_features = pipeline.named_steps['feature_selection'].get_support()
for i, selected in enumerate(selected_features):
    if selected:
        print(f"- {feature_names[i]}")

# Example with more complex dataset (conceptual)
print("\nConceptual example with more complex dataset...")

# This would be used with a dataset that has mixed feature types
# numeric_features = [0, 1, 2, 3]
# categorical_features = [4, 5]
#
# numeric_transformer = Pipeline(steps=[
#     ('imputer', SimpleImputer(strategy='median')),
#     ('scaler', StandardScaler())
# ])
#
# categorical_transformer = Pipeline(steps=[
#     ('imputer', SimpleImputer(strategy='most_frequent')),
#     ('onehot', OneHotEncoder(handle_unknown='ignore'))
# ])
#
# preprocessor = ColumnTransformer(
#     transformers=[
#         ('num', numeric_transformer, numeric_features),
#         ('cat', categorical_transformer, categorical_features)
#     ])
#
# pipeline = Pipeline(steps=[
#     ('preprocessor', preprocessor),
#     ('classifier', RandomForestClassifier(random_state=42))
# ])
#
# pipeline.fit(X_train, y_train)

# Parallel processing example
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import time

print("\nParallel Processing Example...")

# Create a larger dataset for demonstration
X_large = np.vstack([X_train] * 10)  # Duplicate data to make it larger
y_large = np.hstack([y_train] * 10)

print(f"Large dataset shape: {X_large.shape}")

# Time single-core processing
print("\nTraining with single core...")
start_time = time.time()
rf_single = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=1)
scores_single = cross_val_score(rf_single, X_large, y_large, cv=5)
single_time = time.time() - start_time

print(f"Single core accuracy: {scores_single.mean():.4f} (±{scores_single.std():.4f})")
print(f"Single core time: {single_time:.2f} seconds")

# Time multi-core processing
print("\nTraining with multiple cores...")
start_time = time.time()
rf_multi = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)
scores_multi = cross_val_score(rf_multi, X_large, y_large, cv=5)
multi_time = time.time() - start_time

print(f"Multi core accuracy: {scores_multi.mean():.4f} (±{scores_multi.std():.4f})")
print(f"Multi core time: {multi_time:.2f} seconds")

print(f"\nSpeedup: {single_time/multi_time:.2f}x")

# Incremental learning example
from sklearn.linear_model import SGDClassifier
from sklearn.datasets import make_classification

print("\nIncremental Learning Example...")

# Create a large dataset that would normally not fit in memory
print("Creating large dataset...")
X_large, y_large = make_classification(
    n_samples=100000, n_features=20, n_informative=10,
    n_redundant=5, n_classes=3, random_state=42
)

# Split into batches
batch_size = 1000
batches = [(X_large[i:i+batch_size], y_large[i:i+batch_size])
           for i in range(0, len(X_large), batch_size)]

print(f"Number of batches: {len(batches)}")
print(f"Batch size: {batch_size}")

# Create incremental learning model
model = SGDClassifier(loss='log_loss', random_state=42)

# Train incrementally
print("\nTraining incrementally...")
for i, (X_batch, y_batch) in enumerate(batches):
    model.partial_fit(X_batch, y_batch, classes=np.unique(y_large))
    if i % 10 == 0:
        print(f"Processed batch {i+1}/{len(batches)}")

# Evaluate
print("\nEvaluating model...")
X_test_large, y_test_large = make_classification(
    n_samples=1000, n_features=20, n_informative=10,
    n_redundant=5, n_classes=3, random_state=123
)

accuracy = model.score(X_test_large, y_test_large)
print(f"Incremental learning accuracy: {accuracy:.4f}")