AI / ML Engineer

Handling Missing Values

How convolutions work: A filter (kernel) slides over input, computing dot products at each position → creates feature map showing where patterns appear. Multiple filters detect multiple features.

• Padding: 'same' keeps spatial dimensions, 'valid' reduces them
• Stride: How many pixels the filter moves. Stride 2 halves spatial dimensions
• Max Pooling: Downsamples by taking max in each window → translation invariance
• Global Average Pooling: Collapses spatial dims to 1×1 → used before final dense layer

Self-Attention: Each token attends to every other token. Computes how much each word should "focus on" other words in context.

• Q, K, V: Query, Key, Value — learned linear projections of input
• Multi-Head Attention: Run attention h times in parallel with different projections → capture different types of relationships
• Positional Encoding: Since attention is order-agnostic, add position information via sinusoidal encoding
• BERT: Bidirectional encoder. Pre-trained with Masked Language Model (MLM) + Next Sentence Prediction (NSP). Used for understanding tasks (classification, NER, QA)
• GPT: Decoder-only, autoregressive. Pre-trained to predict next token. Used for generation tasks.
• T5: Encoder-Decoder. Frames all NLP tasks as text-to-text.

1. Forward pass: Compute activations layer by layer, store intermediate values (cache)
2. Compute loss: Compare prediction ŷ with true label y using loss function
3. Backward pass: Use chain rule to compute gradient of loss w.r.t. each parameter: ∂L/∂w = (∂L/∂z)(∂z/∂w)
4. Update weights: w = w - α × ∂L/∂w

# Standard NLP preprocessing pipeline
import re, nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer

def preprocess(text):
    text = text.lower()                              # lowercase
    text = re.sub(r'[^a-z\s]', '', text)            # remove punctuation
    tokens = word_tokenize(text)                     # tokenize
    tokens = [t for t in tokens if t not in stopwords.words('english')]
    lemmatizer = WordNetLemmatizer()
    tokens = [lemmatizer.lemmatize(t) for t in tokens]
    return ' '.join(tokens)

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
import torch

# Load pretrained model
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenize dataset
def tokenize(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128)

tokenized = dataset.map(tokenize, batched=True)

# Training configuration
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    learning_rate=2e-5,         # Low LR for fine-tuning!
    warmup_steps=500,
    weight_decay=0.01,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

trainer = Trainer(model=model, args=training_args,
                  train_dataset=tokenized["train"], eval_dataset=tokenized["test"])
trainer.train()

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier

mlflow.set_experiment("fraud_detection_v2")

with mlflow.start_run(run_name="rf_baseline"):
    # Log hyperparameters
    params = {"n_estimators": 200, "max_depth": 8, "class_weight": "balanced"}
    mlflow.log_params(params)

    model = RandomForestClassifier(**params)
    model.fit(X_train, y_train)

    # Log metrics
    mlflow.log_metric("train_f1", f1_score(y_train, model.predict(X_train)))
    mlflow.log_metric("val_f1",   f1_score(y_val,   model.predict(X_val)))
    mlflow.log_metric("val_auc",  roc_auc_score(y_val, model.predict_proba(X_val)[:,1]))

    # Save model to registry
    mlflow.sklearn.log_model(model, "model", registered_model_name="FraudDetector")

from fastapi import FastAPI
from pydantic import BaseModel
import mlflow.pyfunc
import numpy as np

app = FastAPI()
model = mlflow.pyfunc.load_model("models:/FraudDetector/Production")

class PredictionRequest(BaseModel):
    amount: float
    merchant_category: str
    hour_of_day: int
    user_avg_spend: float

class PredictionResponse(BaseModel):
    fraud_probability: float
    is_fraud: bool

@app.post("/predict", response_model=PredictionResponse)
async def predict(request: PredictionRequest):
    features = np.array([[request.amount, request.hour_of_day, request.user_avg_spend]])
    proba = model.predict(features)[0]
    return PredictionResponse(fraud_probability=proba, is_fraud=proba > 0.5)

# Run: uvicorn app:app --host 0.0.0.0 --port 8000

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import GridSearchCV, StratifiedKFold

numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['job_type', 'education']

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler',  StandardScaler()),
])
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot',  OneHotEncoder(handle_unknown='ignore', sparse=False)),
])

preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_transformer,   numeric_features),
    ('cat', categorical_transformer, categorical_features),
])

pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier',   GradientBoostingClassifier()),
])

# Grid search with cross-validation
param_grid = {
    'classifier__n_estimators': [100, 200],
    'classifier__max_depth':    [3, 5],
    'classifier__learning_rate': [0.05, 0.1],
}
cv = GridSearchCV(pipeline, param_grid, cv=StratifiedKFold(5), scoring='roc_auc', n_jobs=-1)
cv.fit(X_train, y_train)
print(f"Best AUC: {cv.best_score_:.4f}")
print(f"Best params: {cv.best_params_}")

import torch
import torch.nn as nn
from torch.optim import AdamW
from torch.optim.lr_scheduler import CosineAnnealingLR

class MLPClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dims, num_classes, dropout=0.3):
        super().__init__()
        layers, in_dim = [], input_dim
        for h in hidden_dims:
            layers += [nn.Linear(in_dim, h), nn.BatchNorm1d(h), nn.GELU(), nn.Dropout(dropout)]
            in_dim = h
        layers.append(nn.Linear(in_dim, num_classes))
        self.net = nn.Sequential(*layers)

    def forward(self, x): return self.net(x)

device = 'cuda' if torch.cuda.is_available() else 'cpu'
model = MLPClassifier(50, [256, 128, 64], 2).to(device)
optimizer = AdamW(model.parameters(), lr=1e-3, weight_decay=0.01)
scheduler = CosineAnnealingLR(optimizer, T_max=50)
criterion = nn.CrossEntropyLoss()

for epoch in range(50):
    model.train()
    train_loss = 0
    for X_batch, y_batch in train_loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
        optimizer.zero_grad()
        loss = criterion(model(X_batch), y_batch)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # gradient clipping
        optimizer.step()
        train_loss += loss.item()
    scheduler.step()

    model.eval()
    with torch.no_grad():
        val_preds = model(X_val.to(device)).argmax(dim=1).cpu()
    if epoch % 10 == 0:
        print(f"Epoch {epoch}: loss={train_loss/len(train_loader):.4f}")