Data Science & ML Mastery Guide

if(contains(value, "Airport"),
  value.match(/([A-Za-z\s]+Airport)/)[0].trim(),
  ""
)

value.trim().replace(/\s+/, " ").toTitlecase()

if(contains(value, " at "),
  split(value, " at ")[1].trim(),
  value
)

# Python
import re

# Basic airport pattern
pattern = r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s+((?:International\s+)?Airport)\b'

text = "77kg of sandalwood at the Chhatrapati Shivaji Maharaj International Airport"
match = re.search(pattern, text)
if match:
    airport_name = f"{match.group(1)} {match.group(2)}"
    print(airport_name)  # "Chhatrapati Shivaji Maharaj International Airport"

# Basic email pattern
pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

text = "Contact us at support@example.com or admin@site.org"
emails = re.findall(pattern, text)
print(emails)  # ['support@example.com', 'admin@site.org']

# Required packages
import numpy as np
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

# Random Forest (Bagging)
rf = RandomForestClassifier(
    n_estimators=100,
    max_features='sqrt',  # Random feature selection
    bootstrap=True,       # Bootstrap sampling
    oob_score=True       # Out-of-bag error estimation
)

# AdaBoost (Boosting)
ada = AdaBoostClassifier(
    base_estimator=DecisionTreeClassifier(max_depth=1),
    n_estimators=50,
    learning_rate=1.0
)

import numpy as np
from sklearn.linear_model import Lasso, Ridge, LassoCV, RidgeCV
import scipy.io
import matplotlib.pyplot as plt

# Generate sparse signal and measurements
n_measurements, n_pixels = 1300, 2500
A = np.random.normal(0, 1, (n_measurements, n_pixels))
noise = np.random.normal(0, 5, n_measurements)
y = A @ x_true + noise

# Lasso with cross-validation
lasso_cv = LassoCV(alphas=np.logspace(-4, 1, 50), cv=10)
lasso_cv.fit(A, y)
x_lasso = lasso_cv.coef_

# Ridge with cross-validation
ridge_cv = RidgeCV(alphas=np.logspace(-2, 3, 50), cv=10)
ridge_cv.fit(A, y)
x_ridge = ridge_cv.coef_

from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.model_selection import cross_val_score
import numpy as np

# Random Forest with parameter tuning
rf = RandomForestClassifier(
    n_estimators=100,
    max_features='sqrt',     # √p for classification
    max_depth=10,
    min_samples_split=10,
    min_samples_leaf=5,
    oob_score=True,         # Out-of-bag error
    random_state=42,
    n_jobs=-1              # Parallel processing
)

# Parameter sensitivity analysis
max_features_range = [1, 2, 5, 10, int(np.sqrt(n_features)), n_features//3]
oob_errors = []
test_errors = []

for max_feat in max_features_range:
    rf_temp = RandomForestClassifier(max_features=max_feat, oob_score=True)
    rf_temp.fit(X_train, y_train)
    oob_errors.append(1 - rf_temp.oob_score_)
    test_errors.append(1 - rf_temp.score(X_test, y_test))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import KFold

def gaussian_kernel(z, h):
    """Gaussian kernel function"""
    return np.exp(-np.sum(z**2, axis=-1) / (2 * h**2))

def locally_weighted_regression(X_train, y_train, x_pred, h):
    """LWLR at single prediction point"""
    n, p = X_train.shape
    
    # Compute weights
    weights = gaussian_kernel(X_train - x_pred, h)
    
    # Design matrix: [1, (X_train - x_pred)]
    X_design = np.column_stack([np.ones(n), X_train - x_pred])
    
    # Weighted least squares
    W = np.diag(weights)
    XTW = X_design.T @ W
    beta = np.linalg.solve(XTW @ X_design, XTW @ y_train)
    
    # Prediction is β₀
    return beta[0]

# Cross-validation for bandwidth selection
def cross_validate_lwlr(X, y, h_values, cv_folds=5):
    kf = KFold(n_splits=cv_folds, shuffle=True, random_state=42)
    cv_errors = []
    
    for h in h_values:
        fold_errors = []
        for train_idx, val_idx in kf.split(X):
            X_train, X_val = X[train_idx], X[val_idx]
            y_train, y_val = y[train_idx], y[val_idx]
            
            y_pred = [locally_weighted_regression(X_train, y_train, x, h) 
                     for x in X_val.flatten()]
            mse = np.mean((y_val - np.array(y_pred))**2)
            fold_errors.append(mse)
        
        cv_errors.append(np.mean(fold_errors))
    
    return np.array(cv_errors)

from sklearn.model_selection import (
    cross_val_score, KFold, StratifiedKFold, 
    LeaveOneOut, cross_validate, GridSearchCV
)

# Basic cross-validation
from sklearn.model_selection import cross_val_score

# 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
print(f"CV Score: {scores.mean():.3f} (+/- {scores.std() * 2:.3f})")

# Stratified K-Fold for classification
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=skf, scoring='accuracy')

# Manual cross-validation loop
kf = KFold(n_splits=5, shuffle=True, random_state=42)
cv_errors = []

for train_idx, val_idx in kf.split(X):
    X_train, X_val = X[train_idx], X[val_idx]
    y_train, y_val = y[train_idx], y[val_idx]
    
    model.fit(X_train, y_train)
    y_pred = model.predict(X_val)
    error = 1 - accuracy_score(y_val, y_pred)
    cv_errors.append(error)

cv_error = np.mean(cv_errors)
cv_std = np.std(cv_errors)

# Grid search with cross-validation
from sklearn.model_selection import GridSearchCV

param_grid = {
    'max_depth': [3, 5, 7, 10],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

grid_search = GridSearchCV(
    DecisionTreeClassifier(random_state=42),
    param_grid, cv=5, scoring='accuracy', n_jobs=-1
)
grid_search.fit(X, y)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best CV score: {grid_search.best_score_:.3f}")