Walmart Global Tech: Data Scientist (2025)

• No non-linear activations (or identity or linear activations): stacking linear layers gives W₂(W₁x) = Wx, which is still linear.
• Activations operating in their linear region: small pre-activations with tanh or sigmoid near 0, or ReLU units that are all active (always positive), behave linearly.
• Very wide networks at initialisation (NTK regime): with a small learning rate, training behaves like a linear model in the parameters.
• Heavy regularisation pushes weights towards 0, which keeps activations near their linear zone.
• Takeaway: non-linearity comes from the activations; without it, depth adds nothing.

• Purpose: it adds a penalty on the size of the weights to reduce variance and overfitting, especially when features are many or correlated.
• L2 (Ridge), λ‖w‖²: shrinks all weights smoothly, handles multicollinearity, and has a closed form (XᵀX + λI)⁻¹Xᵀy.
• L1 (Lasso), λ‖w‖₁: pushes some weights to exactly 0, which performs feature selection.
• Elastic Net: a mix of both, good when there are groups of correlated features.
• Tune λ with cross-validation and always standardise features first.

• BERT (encoder-only, bidirectional):
• Input: [CLS] tokens [SEP] with segment and position embeddings.
• Trained by masked language modelling (plus NSP originally).
• Output: contextual embeddings for every token. [CLS] is used for classification, and token vectors for NER or QA spans.
• It does not generate free text.
• Original Transformer decoder (in encoder-decoder models such as T5 or translation): uses masked self-attention over the output so far plus cross-attention to the encoder output, and generates the target sequence token by token.
• GPT-3 (decoder-only, causal):
• Input: a prompt. A causal mask means each token sees only earlier tokens.
• Trained on next-token prediction.
• Output: a probability distribution over the next token, sampled repeatedly (autoregressively).
• Supports in-context learning (few-shot) and has 175B parameters.

• LLM-as-judge with a clear rubric (relevance, correctness, completeness, tone, scored 1–5) or pairwise comparison between two systems. Calibrate the judge on 50 to 100 human-labelled items.
• Reference-free metrics:
• Faithfulness or groundedness to the provided context (RAGAS).
• Self-consistency across samples.
• Uncertainty via log-probs.
• Behavioural checks: format and JSON validity, policy and toxicity classifiers, length.
• Human and online signals:
• Expert review of a sample.
• Thumbs up/down.
• Edit distance (how much users change drafts).
• Task success and escalation rate.
• A/B tests.

• PCA (unsupervised):
• Finds orthogonal directions of maximum variance: eigenvectors of the covariance matrix, or the SVD of the centred X.
• Keep the top components that explain, say, 95% of the variance.
• Uses: compression, denoising, visualisation.
• LDA (supervised):
• Finds directions that maximise between-class separation relative to within-class scatter.
• At most (C − 1) components.
• Uses: dimensionality reduction before classification.
• Key difference: PCA ignores labels, so it may keep directions that are useless for classification; LDA uses labels but assumes Gaussian classes with shared covariance.

• TF is how often a term appears in a document. IDF = log(N / (1 + df)) down-weights common words. TF × IDF highlights words that are distinctive for a document.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

docs = ["refund for damaged item", "track my order", "return policy for shoes"]
vec = TfidfVectorizer(ngram_range=(1, 2), stop_words="english")
X = vec.fit_transform(docs)
q = vec.transform(["how to return shoes"])
best = cosine_similarity(q, X).argmax()
print(docs[best])   # return policy for shoes

• Limitations: no semantics (synonyms are missed) and sparse, high-dimensional vectors. Dense embeddings or hybrid search fix this.

import numpy as np
from collections import Counter

def knn_predict(X_train, y_train, X_test, k=5):
    preds = []
    for x in X_test:
        d = np.sqrt(((X_train - x) ** 2).sum(axis=1))
        idx = np.argpartition(d, k)[:k]
        preds.append(Counter(y_train[idx]).most_common(1)[0][0])
    return np.array(preds)

• Prediction is O(n·d) per query, so use KD-trees, ball trees or ANN at scale. Scale features first. Choose k by cross-validation (odd k for binary problems). Distance-weighted voting is a common follow-up.

WITH rev AS (
  SELECT p.category, p.product_id, SUM(o.qty * o.price) AS revenue
  FROM orders o JOIN products p ON p.product_id = o.product_id
  WHERE o.order_date >= CURRENT_DATE - INTERVAL '30' DAY
  GROUP BY p.category, p.product_id
)
SELECT * FROM (
  SELECT rev.*, ROW_NUMBER() OVER (PARTITION BY category ORDER BY revenue DESC) AS rn
  FROM rev
) t WHERE rn <= 3;

• Mention ROW_NUMBER vs RANK for ties, and an index on (order_date, product_id).

1. Clarify the data: which stores, whether the drop is real (data pipeline issues, a holiday calendar shift), and the comparison with last year.
2. Decompose: traffic × conversion × basket size; by region, store and channel (online vs store).
3. Hypotheses: stock-outs, price change or competitor promotion, a product-page or listing change, seasonality, weather.
4. Quantify: a difference-in-differences against control stores, and an inventory join to detect lost sales.
5. Model: a demand forecast (LightGBM with lag, price, promotion and holiday features) to estimate the expected baseline, then attribute the gap to drivers.
6. Recommend actions with the expected impact, and monitor.