AI & ML Comprehensive Knowledge Hub

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score

# Load audit data
X = df[['control_deficiencies', 'prior_findings', 'complexity_score']]
y = df['audit_failure']  # 1=failed, 0=passed

# CRITICAL: Feature scaling for logistic regression
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Train with L2 regularization
model = LogisticRegression(
    C=0.1,              # Regularization strength (inverse)
    penalty='l2',       # L2 regularization
    max_iter=1000,
    solver='lbfgs',
    random_state=42
)

# Cross-validation for robust evaluation
cv_scores = cross_val_score(model, X_scaled, y, cv=5, scoring='f1')
print(f"CV F1 Score: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")

# Train final model
model.fit(X_scaled, y)

# Predictions with probability
y_pred_proba = model.predict_proba(X_test_scaled)[:, 1]
y_pred = model.predict(X_test_scaled)

# Comprehensive evaluation
from sklearn.metrics import classification_report, roc_auc_score
print(classification_report(y_test, y_pred))
print(f"AUC-ROC: {roc_auc_score(y_test, y_pred_proba):.3f}")

from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler

# Feature scaling is CRITICAL for SVM
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# RBF kernel for non-linear classification
svm = SVC(
    kernel='rbf',           # Radial Basis Function
    C=1.0,                  # Regularization parameter
    gamma='scale',          # Kernel coefficient (auto-tuned)
    probability=True,       # Enable probability estimates
    random_state=42
)

# Train
svm.fit(X_train_scaled, y_train)

# Predict
y_pred = svm.predict(X_test_scaled)
y_proba = svm.predict_proba(X_test_scaled)

# Model info
print(f"Support vectors: {svm.n_support_}")
print(f"Classes: {svm.classes_}")

# Evaluate
from sklearn.metrics import accuracy_score, confusion_matrix
print(f"Accuracy: {accuracy_score(y_test, y_pred):.3f}")
print(confusion_matrix(y_test, y_pred))

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
import pandas as pd

# Prepare features (categorical encoding)
X = pd.get_dummies(df[['agency', 'naics_code', 'amount', 'location']])
y = df['award_type']  # 0=competitive, 1=sole-source

# Train Random Forest
rf = RandomForestClassifier(
    n_estimators=100,       # Number of trees
    max_depth=10,           # Prevent overfitting
    min_samples_split=20,   # Minimum samples to split
    min_samples_leaf=10,    # Minimum samples per leaf
    max_features='sqrt',    # Features per split
    random_state=42,
    n_jobs=-1               # Use all CPU cores
)

# Cross-validation
cv_scores = cross_val_score(rf, X, y, cv=5, scoring='f1')
print(f"CV F1: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")

# Train final model
rf.fit(X_train, y_train)

# Feature importance analysis
feature_importance = pd.DataFrame({
    'feature': X.columns,
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

print("Top 10 Most Important Features:")
print(feature_importance.head(10))

# Predictions
y_pred = rf.predict(X_test)
y_proba = rf.predict_proba(X_test)

# Evaluate
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))

from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler

# Binary target (e.g., digit 5 detection)
binary_target = (digits.target == 5).astype(int)

# MUST scale features for SGD
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train SGD with SVM loss
sgd = SGDClassifier(
    loss='hinge',           # SVM with hinge loss
    penalty='l2',           # L2 regularization
    alpha=0.0001,           # Regularization strength
    max_iter=1000,          # Maximum iterations
    tol=1e-3,               # Stopping criterion
    learning_rate='optimal',# Adaptive learning rate
    random_state=42
)

# Train
sgd.fit(X_train_scaled, y_train)

# Cross-validation for robust evaluation
from sklearn.model_selection import cross_val_score
cv_scores = cross_val_score(sgd, X_train_scaled, y_train, cv=5)
print(f"CV Accuracy: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")

# Predict
y_pred = sgd.predict(X_test_scaled)

# For online learning (incremental):
# sgd.partial_fit(X_new_batch, y_new_batch, classes=[0, 1])

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# Prepare features
X = df[['total_budget', 'execution_rate', 'variance_score']]

# Scale features (important for K-Means)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Elbow method to find optimal K
inertias = []
K_range = range(2, 11)
for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X_scaled)
    inertias.append(kmeans.inertia_)

# Plot elbow curve
plt.plot(K_range, inertias, 'bo-')
plt.xlabel('Number of Clusters (K)')
plt.ylabel('Inertia')
plt.title('Elbow Method For Optimal K')

# Train with optimal K (e.g., K=4)
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)

# Add cluster labels to dataframe
df['cluster'] = clusters

# Analyze clusters
cluster_summary = df.groupby('cluster').agg({
    'total_budget': 'mean',
    'execution_rate': 'mean',
    'variance_score': 'mean'
}).round(2)

print(cluster_summary)

from sklearn.mixture import GaussianMixture
import numpy as np

# Train GMM
gm = GaussianMixture(n_components=3, n_init=10, random_state=42)
gm.fit(X)

# Model parameters
print(f"Converged: {gm.converged_}")
print(f"Iterations: {gm.n_iter_}")
print(f"Weights: {np.round(gm.weights_, 2)}")

# Soft clustering (probabilities)
probabilities = gm.predict_proba(X)
print(f"Sample belongs to cluster 0 with prob: {probabilities[0, 0]:.3f}")

# Hard clustering (assign to most probable cluster)
clusters = gm.predict(X)

# Anomaly detection using density
densities = gm.score_samples(X)
density_threshold = np.percentile(densities, 4)  # Bottom 4%
anomalies = X[densities < density_threshold]

print(f"Detected {len(anomalies)} anomalies")

# Use BIC/AIC to select optimal number of components
bics = []
for k in range(1, 10):
    gm = GaussianMixture(n_components=k, n_init=10)
    gm.fit(X)
    bics.append(gm.bic(X))

optimal_k = np.argmin(bics) + 1
print(f"Optimal number of components: {optimal_k}")