scikit-learn: Classification, Regression & Clustering

Classification Algorithms

from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import (
    RandomForestClassifier, GradientBoostingClassifier,
    AdaBoostClassifier, BaggingClassifier, VotingClassifier
)
from sklearn.svm import SVC, LinearSVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neural_network import MLPClassifier

# Common classifiers with sensible defaults
models = {
    'Logistic Regression': LogisticRegression(max_iter=1000, C=1.0),
    'Random Forest':       RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting':   GradientBoostingClassifier(n_estimators=100, learning_rate=0.1),
    'SVM (RBF kernel)':    SVC(C=1.0, kernel='rbf', probability=True),
    'KNN':                 KNeighborsClassifier(n_neighbors=5),
    'Naive Bayes':         GaussianNB(),
}

# Fit and predict
for name, model in models.items():
    model.fit(X_train, y_train)
    score = model.score(X_test, y_test)
    print(f"{name}: {score:.4f}")

# Predict probabilities
model.predict(X_test)                  # class labels
model.predict_proba(X_test)            # probability per class
model.predict_proba(X_test)[:, 1]     # positive class probability (binary)

# Multiclass strategies
from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier
ovr = OneVsRestClassifier(SVC())
ovr.fit(X_train, y_train)

Regression Algorithms

from sklearn.linear_model import (
    LinearRegression, Ridge, Lasso, ElasticNet, BayesianRidge
)
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.svm import SVR
from sklearn.tree import DecisionTreeRegressor

# Linear models
LinearRegression()              # OLS — no regularization
Ridge(alpha=1.0)                # L2 regularization — shrinks coefficients
Lasso(alpha=0.1)                # L1 regularization — zeroes out features
ElasticNet(alpha=0.1, l1_ratio=0.5)  # L1 + L2

# Tree-based
RandomForestRegressor(n_estimators=100, random_state=42)
GradientBoostingRegressor(n_estimators=200, learning_rate=0.05, max_depth=4)

# Fit and predict
reg = Ridge(alpha=1.0)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)

# Coefficients
reg.coef_                   # feature coefficients
reg.intercept_              # bias term

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

Clustering

from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering, MeanShift
from sklearn.mixture import GaussianMixture

# K-Means (must specify k)
kmeans = KMeans(n_clusters=5, random_state=42, n_init=10)
labels = kmeans.fit_predict(X)
centers = kmeans.cluster_centers_

# Elbow method to find optimal k
inertias = []
for k in range(1, 11):
    km = KMeans(n_clusters=k, random_state=42, n_init=10).fit(X)
    inertias.append(km.inertia_)

# DBSCAN (density-based — finds clusters of arbitrary shape, handles noise)
dbscan = DBSCAN(eps=0.5, min_samples=5)
labels = dbscan.fit_predict(X)
# Labels: -1 = noise, 0, 1, 2, ... = clusters

# Agglomerative (hierarchical)
agg = AgglomerativeClustering(n_clusters=5, linkage='ward')
labels = agg.fit_predict(X)

# Evaluate clustering (no ground truth)
from sklearn.metrics import silhouette_score, davies_bouldin_score
sil_score = silhouette_score(X, labels)      # higher = better (-1 to 1)
db_score = davies_bouldin_score(X, labels)   # lower = better

# Dimensionality reduction for visualization
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE

pca = PCA(n_components=2)
X_2d = pca.fit_transform(X)

tsne = TSNE(n_components=2, random_state=42, perplexity=30)
X_tsne = tsne.fit_transform(X)