pip install scikit-learn pandas numpy matplotlib seaborn xgboost optuna kaggle

# config.py
import os
os.environ['KAGGLE_USERNAME'] = 'yourname'
os.environ['KAGGLE_KEY'] = 'yourkey'

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"RMSE: {mean_squared_error(y_test, y_pred, squared=False):.2f}")
print(f"R²: {r2_score(y_test, y_pred):.3f}")

from sklearn.linear_model import LogisticRegression

model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train)
y_prob = model.predict_proba(X_test)[:, 1]

from sklearn.metrics import roc_auc_score
print(f"AUC: {roc_auc_score(y_test, y_prob):.4f}")

from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier

models = {
    'RF': RandomForestClassifier(n_estimators=200),
    'SVM': SVC(probability=True),
    'KNN': KNeighborsClassifier()
}

for name, model in models.items():
    model.fit(X_train, y_train)
    auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])
    print(f"{name} AUC: {auc:.4f}")

from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('True')
plt.xlabel('Predicted')

from sklearn.model_selection import cross_val_score

scores = cross_val_score(model, X, y, cv=5, scoring='roc_auc')
print(f"CV AUC: {scores.mean():.4f} ± {scores.std():.4f}")

import xgboost as xgb

model = xgb.XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    eval_metric='auc'
)
model.fit(X_train, y_train, 
          eval_set=[(X_test, y_test)], 
          early_stopping_rounds=50, 
          verbose=False)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer

numeric_features = ['age', 'fare']
categorical_features = ['sex', 'embarked']

preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numeric_features),
    ('cat', OneHotEncoder(), categorical_features)
])

pipeline = Pipeline([
    ('prep', preprocessor),
    ('model', xgb.XGBClassifier())
])

# Grid Search
from sklearn.model_selection import GridSearchCV
param_grid = {'model__max_depth': [3, 5, 7]}
grid = GridSearchCV(pipeline, param_grid, cv=5, scoring='roc_auc')
grid.fit(X, y)

# Optuna (Faster!)
import optuna
def objective(trial):
    params = {
        'max_depth': trial.suggest_int('max_depth', 3, 10),
        'learning_rate': trial.suggest_float('lr', 0.01, 0.3)
    }
    model = xgb.XGBClassifier(**params)
    return cross_val_score(model, X, y, cv=3, scoring='roc_auc').mean()

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50)

ml-core-capstone/
├── house_prices/
│   ├── notebook.ipynb
│   ├── submission.csv (RMSE: 0.118)
│   └── model.pkl
├── santander/
│   ├── notebook.ipynb
│   └── submission.csv (AUC: 0.902)
└── README.md

# ML Core Capstone: Kaggle Top 20%

## House Prices (RMSE: 0.118 – Top 18%)
- Feature eng: TotalSF, Age, Neighborhood encoding
- XGBoost + Optuna (50 trials)
- Cross-validation: 5-fold

## Santander (AUC: 0.902 – Top 15%)
- PCA on 200 anon features
- Early stopping + class weights

**Tech**: Scikit-learn, XGBoost, Optuna, Pandas  
**Live**: [kaggle.com/yourname](https://www.kaggle.com/yourname)

kaggle competitions download -c house-prices-advanced-regression-techniques
unzip house-prices-advanced-regression-techniques.zip