Intel & AMD: AI Engineer

• Convert and compile: export to ONNX, then use a vendor runtime/compiler (OpenVINO for Intel CPUs, GPUs and NPUs; ONNX Runtime with an execution provider). These fuse operators and choose optimised kernels.
• Quantize: INT8 post-training quantization with calibration data (or quantization-aware training if accuracy drops); INT4 weight-only for LLMs.
• Model choices: a smaller or distilled model, pruning, static shapes, batch size tuned to the latency target.
• Measure: latency (p50/p95), throughput and power on the target device, plus the change in accuracy against FP32.

SELECT region, product, total
FROM (
  SELECT region, product, SUM(amount) AS total,
         ROW_NUMBER() OVER (PARTITION BY region ORDER BY SUM(amount) DESC) AS rn
  FROM sales GROUP BY region, product
) t
WHERE rn <= 2;

• Practise writing SQL by hand: interviewers check syntax and logic without autocomplete.

• Connect your past to AI: "In electronics I worked with signal data and saw how ML could automate defect detection. That led me to build a CNN classifier for PCB defects at 94% accuracy."
• Show deliberate learning: courses, projects, a deployed demo, open-source work.
• Turn it into an advantage: domain knowledge (hardware, finance, healthcare) helps you frame problems better than pure ML generalists.

• ROCm is AMD's open GPU compute stack (HIP programming model, libraries such as rocBLAS and MIOpen) with PyTorch and JAX support. CUDA is NVIDIA's proprietary equivalent, with the most mature ecosystem.
• For ML engineers: most PyTorch code runs on both, since PyTorch builds for ROCm. Custom CUDA kernels can be ported with HIPify. Performance depends on library maturity for specific operators.
• Inference stacks (vLLM, ONNX Runtime) support both. Benchmark your model, because results vary.

def merge(intervals):
    intervals.sort(key=lambda x: x[0]); out = []
    for s, e in intervals:
        if out and s <= out[-1][1]: out[-1][1] = max(out[-1][1], e)
        else: out.append([s, e])
    return out

• Sort by start, then sweep: O(n log n).

• Map floats to 8-bit integers: q = round(x / scale) + zero_point. Use per-channel scales for weights and per-tensor scales for activations.
• Calibration: run representative data to choose activation ranges (min-max, percentile, entropy/KL).
• Keep accuracy: leave sensitive layers (first and last, attention softmax) in FP16, use SmoothQuant for LLM activations with outliers, or use quantization-aware training.
• Validate on the full evaluation set. A typical drop is under 1% for CNNs and varies for LLMs.