Adobe: Machine Learning Engineer

import torch, torch.nn as nn, torchvision as tv
from torch.utils.data import DataLoader

tf = tv.transforms.Compose([tv.transforms.Resize((64, 64)), tv.transforms.ToTensor(),
                            tv.transforms.Normalize([.5] * 3, [.5] * 3)])
train = tv.datasets.ImageFolder("data/train", tf); val = tv.datasets.ImageFolder("data/val", tf)
dl, vl = DataLoader(train, 64, shuffle=True), DataLoader(val, 128)
model = tv.models.resnet18(weights="IMAGENET1K_V1"); model.fc = nn.Linear(512, len(train.classes))   # transfer learning
opt, lossf = torch.optim.AdamW(model.parameters(), 1e-3), nn.CrossEntropyLoss()
for epoch in range(3):
    model.train()
    for x, y in dl:
        opt.zero_grad(); lossf(model(x), y).backward(); opt.step()
    model.eval(); correct = total = 0
    with torch.no_grad():
        for x, y in vl: correct += (model(x).argmax(1) == y).sum().item(); total += len(y)
    print(epoch, correct / total)

• Transfer learning from a pre-trained backbone is the fastest route to good accuracy. Mention augmentation, a learning-rate schedule and class imbalance if you have time.

• Baseline (2 minutes): TF-IDF + logistic regression. It is often strong.
• DNN: an embedding layer → mean pool (or a BiLSTM/CNN) → dense → softmax. Or fine-tune DistilBERT if a GPU and time allow.

import torch.nn as nn
class TextClf(nn.Module):
    def __init__(self, vocab, n_cls, d=128):
        super().__init__(); self.emb = nn.EmbeddingBag(vocab, d, mode="mean"); self.fc = nn.Linear(d, n_cls)
    def forward(self, ids, offsets): return self.fc(self.emb(ids, offsets))

• Report macro-F1 for imbalanced classes and show a confusion matrix.

import numpy as np
from collections import Counter

def knn(Xtr, ytr, Xte, k=3):
    out = []
    for x in Xte:
        d = np.linalg.norm(Xtr - x, axis=1)
        nn_idx = np.argsort(d)[:k]
        out.append(Counter(ytr[nn_idx]).most_common(1)[0][0])
    return np.array(out)

• State the complexity (O(n·d) per query), the need to scale features, choosing k, ties, and faster search (KD-tree, FAISS).

• Commercially safe training data (licensed or owned content) and content credentials (C2PA provenance) are key differentiators.
• Controllability: inpainting, outpainting, style and structure reference, editing that fits creative workflows (Photoshop's Generative Fill).
• MLE concerns:
• Latency and cost of diffusion inference: fewer sampling steps, distillation (LCM, consistency models), batching, GPU scheduling.
• Safety filters.
• Evaluation (FID/CLIP score plus human creative ratings).
• Personalisation without leaking IP.

• Real ML work depends on choosing the right problem framing, data, metrics and trade-offs: knowing when a simple model wins, spotting leakage, defining the evaluation and planning deployment.
• Domain judgement means connecting the ML to the product (for creative tools: user intent, quality perception, latency tolerance), and debugging models (error analysis, data issues).
• Prepare ML case discussions and past-project trade-offs, not just algorithms.

• Past: a concise impact story with metrics (2–3 minutes). Highlight a decision you owned.
• Future: "Grow into an ML engineer who owns end-to-end features: model, serving and evaluation. I'm especially interested in generative imaging and the inference efficiency that makes it usable inside creative apps."
• Tie your goals to Adobe's products (Firefly, Express, Document Cloud AI Assistant).