Data Science for Marketing Analytics

1. 1Separate learned parameters from hyperparameters before you tune. Learned parameters (regression coefficients, the SVM margin) come from fitting. Hyperparameters (number of clusters, lasso alpha, number of leaf nodes in a tree, SVM C, kernel, gamma, mean-shift quantile/bandwidth) must be optimized separately. Write the list of hyperparameters for the chosen algorithm.
2. 2Preprocess first. Standardize features on very different scales (the passages contrast ranges of -1 to 7 against 0 to 374457) with StandardScaler or z-score columns. Preprocessing is described as the first step to improving accuracy, and distance-based methods like k-means depend on it.
3. 3Fix a baseline with cross-validation before searching. Run k-fold (cv=10 via cross_val_score, or StratifiedKFold) on the untuned model and record the mean score. In the passages, logistic regression on the top5 features gives 0.790.
4. 4Pick the scoring measure that fits the task. For supervised models use CV accuracy (or a metric such as precision, recall, F1). For clustering, use the average silhouette score, which runs from -1 to 1 and works for both choosing k and comparing algorithm types.
5. 5Define a deliberately small search space. For an SVM, use a list of dicts so that invalid combinations are never built: {'kernel':['linear'],'C':[0.1,1,10]} and {'kernel':['rbf'],'gamma':[0.5,1,2],'C':[0.1,1,10]}. Grid search brute-forces every combination, so choose values wisely.
6. 6Run the search with cross-validation inside it: GridSearchCV(svm.SVC(), parameters, cv=StratifiedKFold(n_splits=10)), then .fit on the training data only. Read best_score_ and best_params_.
7. 7If the grid is too slow, switch to randomized search. Supply distributions and set n_iter as the computational budget.
8. 8For clustering, sweep the hyperparameter and score each setting. Loop k over 2 to 10 (krange), store each average silhouette in avg_silhouettes, and plot. For mean-shift, sweep the quantile used in estimate_bandwidth the same way. Treat the chosen value as a fit measure, then check that the clusters are actually useful.

Exercise 42 tunes an SVM for customer churn on the top5_features. The data is preprocessed first, and logistic regression with 10-fold CV sets a baseline accuracy of 0.790. The search space is two dicts: a linear kernel with C in [0.1, 1, 10], and an rbf kernel with gamma in [0.5, 1, 2] and C in [0.1, 1, 10]. That is 3 + 9 = 12 candidate settings, each scored through StratifiedKFold(n_splits=10). GridSearchCV(svm.SVC(), parameters, cv=StratifiedKFold(n_splits=10)) is fit on X_train[top5_features] and y_train. The reported best parameters are C=0.1, gamma=0.5, kernel=rbf. The passage's note is that grid search is slow, so the grid must be chosen sensibly. For clustering, Exercise 18 applies the same logic. It runs k-means for k=2 to 10, averages the silhouette per k, and compares the best against mean-shift on the same standardized four_cols data.

• If the model has few hyperparameters with a small set of plausible values, use GridSearchCV. If the grid is large and runtime is a problem, use randomized search with n_iter as the budget.
• If a hyperparameter only applies to one kernel (gamma for rbf, not linear), put it in a separate dict in the grid instead of crossing everything.
• If you need to choose k or compare k-means with mean-shift, use the silhouette score. Closer to 1 is a better fit, and a negative value means points sit nearer another cluster.
• If the quantitative score picks a k but the segments are not useful for the business, do not use that clustering. The measures say how well k fits the data, not how useful the clusters are.
• If you want an algorithm that avoids choosing k, expect to tune something else. Mean-shift swaps k for a bandwidth quantile, but it can fit some datasets better and scales poorly to large ones.

• Tuning on unstandardized data. The tell: features with ranges like 0 to 374457 dominate and the best parameters shift once you scale.
• Oversized grids. The tell: GridSearchCV runs for a very long time because it exhausts every combination. Trim values, split by kernel, or use randomized search.
• Treating the best score as the goal of the clustering. The tell: a high silhouette k produces segments nobody can act on.
• Judging by eye or elbow only. The tell: two people read the same plot and pick different k, because visual inspection and the elbow method depend on individual judgment.
• Skipping a baseline or cross-validation. The tell: you cannot say whether the tuned accuracy beats the untuned 0.790, or the gain comes from a single lucky split.

• ▸Algorithm and task: name the model and whether it is supervised or clustering.
• ▸Learned parameters vs. hyperparameters: list each, and mark which ones you will tune.
• ▸Preprocessing applied: record the scaling or standardization step and the features covered.
• ▸Baseline score: give the metric and the untuned CV result (e.g., 10-fold mean).
• ▸Search method: choose grid, randomized (with n_iter), or a sweep (such as k from 2 to 10).
• ▸Search space: write each hyperparameter and its candidate values, split by kernel where needed.
• ▸CV scheme: state the folds and whether they are stratified.
• ▸Best parameters and best score: record best_params_ and best_score_ (or the best silhouette).
• ▸Usefulness check: state whether the result is meaningful for the business and the decision.

1. 1Measure the class split before touching a model. Count each class in the target and write down the proportions. The source's reference case is one class at 90% and another at 10%. If the split is near that, treat the data as imbalanced.
2. 2Set the baseline a model must beat. A classifier that always predicts the majority class scores about 90% accuracy on a 90/10 split, so accuracy alone cannot show whether the minority class is learned. Record this number before any model is fit.
3. 3Split with stratification. Plain k-fold 'doesn't work well' under imbalance. Use StratifiedKFold (the source uses n_splits=10, random_state=1 on the bank churn data) so each fold keeps the original class ratio.
4. 4Fit an untouched baseline first (Exercise 47 does this: classification on imbalanced data). Score it with the confusion matrix and with precision, recall, F1 and the ROC curve, not accuracy alone. This is the 'before' you compare against.
5. 5Pick the correction by model type. The source says decision trees split on the majority class and generalize poorly, and its remedy is to balance the data before fitting. It also lists random forest as usable on highly imbalanced data, which makes a forest the natural base learner for the sampling experiments.
6. 6Visualize each sampling technique before committing (Exercise 48). Plot the class distribution after undersampling, oversampling and SMOTE, and check how the minority class is represented in each.
7. 7Fit the chosen learner on the rebalanced training data (Exercise 49 fits a random forest classifier using SMOTE) and build the confusion matrix. Compare minority-class recall and precision against the baseline from step 4.
8. 8Keep the stratified cross-validation folds and the test data at their natural class ratio. Rebalancing is a training-time correction only, so the evaluation still reflects the real class mix. This is standard practice, not stated in the supplied passages.

The passages give the setup rather than numbers, so this example is partly illustrative. Take a dataset where one class is 90% of samples and another is 10%, the split the source uses to describe imbalance. A model that predicts only the majority class scores 90% accuracy and finds zero minority cases, which is the failure the source describes for decision trees: they split on the majority class and 'don't generalize very well'. First, split with StratifiedKFold (n_splits=10) so every fold holds roughly 90/10, as in the bank churn exercise (Exercise 41). Second, fit the baseline and read its confusion matrix: the minority-class row exposes the problem that the accuracy figure hides. Third, plot the sampling techniques (Exercise 48) and fit a random forest classifier with SMOTE (Exercise 49). Fourth, build the new confusion matrix and check whether minority-class hits rise. The comparison of the two confusion matrices is what the correction is judged on.

• If one class is near 90% or more of the samples, then stop reporting accuracy alone and add the confusion matrix, precision, recall and F1.
• If you cross-validate on imbalanced data, then use stratified k-fold, not plain k-fold, so each fold keeps the class ratio.
• If the model is a single decision tree, then balance the data first. The source says the tree splits on the majority class and is biased.
• If you use a random forest, then still run the baseline-versus-resampled comparison. The source calls forests usable on highly imbalanced data, but that does not replace measuring minority-class recall.
• If a resampling method looks questionable, then plot it first (as in Exercise 48) and check the resulting distribution before fitting.

• Trusting accuracy: a high score such as 90% with no minority-class predictions. The tell is a confusion matrix whose minority row is nearly empty.
• Plain k-fold on skewed data: fold scores vary widely or some folds hold almost no minority cases. The tell is unstable cross-validation results. Fix it with stratified k-fold.
• Fitting a decision tree on raw skewed data and expecting it to generalize: the tree splits on the majority class. The tell is strong training fit with weak minority recall.
• Rebalancing the evaluation data too (a practice point beyond the passages): scores look better but no longer reflect real class proportions. The tell is a test set whose class mix differs from production.
• Applying SMOTE or sampling without a baseline: you cannot tell whether it helped. The tell is a single confusion matrix and no before/after comparison.

• ▸Target variable and classes: name each class being predicted.
• ▸Class proportions: count and percentage per class (flag if near 90/10).
• ▸Majority-class baseline accuracy: the score from always predicting the majority class.
• ▸Split method: stratified k-fold, with n_splits and random_state noted.
• ▸Baseline model and confusion matrix: model fit on unmodified data, with minority-class hits and misses.
• ▸Baseline precision / recall / F1 / ROC: the metrics before any correction.
• ▸Technique tried: undersampling, oversampling, SMOTE or class weighting, plus the plot you checked.
• ▸Post-correction confusion matrix and metrics: same model and folds as the baseline.
• ▸Decision: keep, change or drop the technique, with the minority-recall change as the reason.

1. 1Split before you fit. Use train_test_split (the book uses random_state=10 in Exercise 24) to produce X_train, X_test, y_train, y_test, and fit only on the training portion. Test data stays untouched until you judge the model.
2. 2Fit a baseline and inspect it. In Exercise 24, a plain LinearRegression fit on 20 scores gives 20 coefficients (model.coef_), many large in both directions (e.g., 31.05, -17.20, -38.21). Large, scattered weights across features you cannot interpret signal a model that may be chasing noise.
3. 3Constrain the weights with regularization. Regularization adds a second goal: predict the training points accurately while minimizing the weight on each variable. Lasso regression drops variables that are not useful, so you keep as few features as possible without losing predictive ability.
4. 4Score on held-out data, not training data. Use the test set with a metric suited to the task: MAE or RMSE for regression (Chapter 6), accuracy via clf.score(X_test, y_test) for classification (Exercise 36 gives 0.775 on test data).
5. 5Use cross-validation for a sturdier estimate. Use stratified k-fold (Exercise 41) so every fold keeps the class proportions, then compare the fold scores rather than relying on one split.
6. 6Fine-tune hyperparameters against validation folds. For SVMs, the kernel function and the regularization term matter. A large margin lowers generalization error, while a small margin risks overfit. Try a soft-margin classifier (slack variable ξ) when the classes cannot be separated perfectly.
7. 7Compare candidate models on the same held-out data. Compare linear regression, lasso, and random forests (Chapter 6), or SVM, decision tree, and random forest (Chapter 8). Choose the model whose held-out performance holds up, not the one with the best training fit.
8. 8For imbalanced classes, go beyond accuracy. Check precision, recall, F1, and the ROC curve, and rebalance the training data (SMOTE, Chapter 9) before refitting.

Exercise 24 gives you store revenue plus 20 unlabeled internal scores, and the task is a predictive model that uses as few scores as possible without sacrificing the ability to predict location revenue. You read 20scores.csv into df, set X to all columns after the first and y to 'revenue', and split with train_test_split(X, y, random_state=10). You fit LinearRegression on the training data and print model.coef_. The output is 20 coefficients of mixed sign and size, such as 31.05, 1.36, -17.20, and -38.21. Every score carries some weight, so you cannot tell which ones matter. You then fit lasso regression, whose regularization pushes useless variables' weights toward being dropped entirely. The surviving variables define a smaller model that is still a simple equation. You judge the smaller model on X_test and y_test using MAE and RMSE and compare it against the full linear model. If the error on held-out data is about the same, the extra features were noise, and the compact model is the one that generalizes.

• If a model's performance is reported on the same data it was trained on, then treat it as unvalidated and rescore on a held-out test set.
• If you have many features and the coefficients are large and mixed in sign, then add lasso regularization and keep only the features that survive.
• If the data are linearly inseparable, then use a soft-margin SVM (slack ξ) rather than a hard margin, which demands zero errors and tends to overfit.
• If the class labels are imbalanced, then use stratified k-fold and judge by precision, recall, F1, or ROC rather than accuracy alone.
• If two models score about equally on held-out data, then choose the simpler one with fewer features.

• Evaluating on training data: the tell is near-perfect scores that collapse on the test set.
• Letting test data influence choices (tuning, feature selection, scaling) so the held-out score is no longer independent: the tell is a test score that looks suspiciously good and then drops on new data.
• Using a single train-test split and trusting it: the tell is a score that changes noticeably when random_state changes. Cross-validation exposes this.
• Reading accuracy on imbalanced classes as success: the tell is a high accuracy alongside poor recall or a confusion matrix dominated by the majority class.
• Keeping every feature because the full model fits best: the tell is many large, opposing coefficients and no gain in test error when features are removed.

• ▸Model and task: name the model and whether it is regression or classification.
• ▸Split method: record the train/test split and random_state, and confirm the test set was not touched during fitting.
• ▸Training score: record the metric and value on training data.
• ▸Held-out score: record the same metric on the test data; note the gap from training.
• ▸Cross-validation: record the number of folds, whether stratified, and the score per fold.
• ▸Regularization / complexity controls: list the regularization term, kernel, or features dropped.
• ▸Feature count: record features before and after selection.
• ▸Comparison models: list alternative models and their held-out scores.
• ▸Decision: choose the model and justify it by held-out performance and simplicity.

1. 1Fix the evaluation set before modeling. Split with train_test_split and a stated random_state (the book's lasso exercise uses random_state=10). Fit only on the training portion and keep the test portion untouched until you score.
2. 2Match the metric to the task. Regression gets MAE and RMSE. Clustering gets silhouette score. Classification gets precision, recall, F1 and the ROC curve. Write the metric down before you see any results.
3. 3For regression, compute residuals (prediction minus true value) on the test data, then MAE and RMSE from them. Read both numbers together. MAE is the typical miss. RMSE weights large misses more heavily, so a wide gap between them signals a few big errors.
4. 4For clustering, calculate the silhouette score for each candidate k in k-means and for the mean-shift result. Choose by the score, not by the elbow alone. Then use a train-test split: fit on train, assign test points to clusters, and check the score holds.
5. 5For classification, build the confusion matrix first, then derive precision, recall and F1 from it, and plot the ROC curve. Use stratified k-fold so each fold keeps the class proportions.
6. 6If classes are imbalanced, report the metrics per class. Resample (for example SMOTE) only on the training data, then rebuild the confusion matrix on the untouched test set.
7. 7For multiclass problems, use the multiclass versions of the performance metrics rather than a single binary score.
8. 8Compare every candidate on the same split and the same metric, including simpler versions (for example, lasso with fewer features). Record the winner with its test score, not its training score.

The book's lasso exercise (Exercise 24) uses store revenue data with 20 unlabeled scores. The goal is a model that uses as few scores as possible without losing predictive ability. You split with random_state=10, with revenue as y and the 20 scores as X. You fit ordinary LinearRegression on the training set and inspect model.coef_. Most coefficients are small, such as 31.05, 1.36 and -17.20, but one is 9.1258e+03. That outlier tells you the ordinary model leans heavily on a single variable. A lasso model is then used to drop the unhelpful scores. The accuracy check is the book's regression evaluation: compare model predictions with the true test values and compute MAE and RMSE. The book's Exercise 23 prints a pair of results, (0.906..., 1.155...). The second is larger, which is consistent with RMSE being at least MAE. You keep the smaller lasso model only if its test MAE and RMSE stay close to the full model's.

• If RMSE is much larger than MAE, then a few large misses dominate. Inspect those residuals before you tune the model.
• If lasso drops variables and the test MAE and RMSE barely change, then ship the smaller model. If they rise, restore the dropped variables.
• If k-means at several k and mean-shift give similar silhouette scores, then prefer the segmentation that is easier to explain. If one is clearly higher on held-out data, then use it.
• If the classes are imbalanced, then do not trust overall accuracy. Decide between precision and recall by the cost of each error type, and check F1 and the confusion matrix.
• If a score looks excellent on the training data, then re-score on the test set or with stratified k-fold before you report it.

• Scoring on the training data. The tell is near-perfect metrics that collapse on the test split.
• Reading RMSE or MAE with no baseline. The tell is a number such as 0.906 quoted with no comparison to another model or to the spread of the outcome.
• Picking k from the elbow plot alone. The tell is no silhouette score reported and no check against mean-shift.
• Judging an imbalanced classifier by accuracy. The tell is high accuracy alongside a confusion matrix with a near-empty minority-class column.
• Resampling before the split, so synthetic points leak into the test set. The tell is minority-class metrics that look too good after SMOTE.
• Changing the random_state or the metric until the result looks good. The tell is an unrepeatable score.

• ▸Task type: regression, clustering, or classification (binary or multiclass).
• ▸Split method and seed: train-test split with random_state, or stratified k-fold with number of folds.
• ▸Primary metric: MAE/RMSE, silhouette, or precision/recall/F1/AUC, chosen before modeling.
• ▸Baseline and candidates: list each model or k compared, including the simplest version.
• ▸Test-set scores: one value per candidate per metric, on held-out data only.
• ▸Error shape: RMSE vs MAE gap, or the confusion matrix and per-class recall.
• ▸Class balance check: class proportions, and whether resampling was applied to training data only.
• ▸Decision: chosen model, the score that justifies it, and the error type you accept.
• ▸Re-score trigger: what change in data or score would send you back to retrain.

1. 1Write the business question and the KPI before touching a model. The source says KPIs are target metrics that quantify business expectations, and that you must be clear about the scope of the data, the questions it can address and the problems it can solve before drawing inference. Name the decision the analysis feeds (who to target, what to spend, which customers to retain).
2. 2Run exploratory data analysis and check that each attribute agrees with business intuition. If values don't make sense, dig into them, remove outliers and find out why the attribute holds those values. The source warns that skipping this leads to inaccurate models, models built on the wrong data, and inefficient use of resources.
3. 3Summarize attributes and compare them with your KPIs. Use pandas aggregations, pivot tables and Matplotlib/seaborn visuals to see how attributes relate to the target metric, and decide which attributes the analysis actually needs.
4. 4Build interpretable segments with clustering. Standardize the data first (the book's example uses age and income), then run k-means or hierarchical clustering, and pick the segmentation approach by evaluation, not by default. Profile each cluster in business terms so a marketer can describe it in one sentence.
5. 5Predict customer value with regression. Check predictor–outcome relationships with visualizations and correlations, fit a linear model for customer spend or lifetime value, and evaluate it with MAE and RMSE. Use Lasso regularization to drop weak features, and tree-based models or random forests when trends are non-linear.
6. 6Model churn or customer choice as a classification problem. Use logistic regression and a pipeline (obtain, scrub, explore, model), and read the coefficients and feature importances to identify churn drivers. Evaluate with multiclass metrics and a confusion matrix, not accuracy alone.
7. 7Handle class imbalance before trusting a churn model. Rare churners can make a model look accurate while it misses them. Apply sampling techniques such as SMOTE, then rebuild the confusion matrix and check the minority class.
8. 8Translate outputs into actions with a resource allocation. For each segment or risk tier, state the action, the driver it addresses, and the expected ROI effect. Rank by value times responsiveness, fund the top tiers, and set the KPI that will confirm the result.

The source reports the kind of payoff this work aims at. Predictive algorithms generating marketing leads at Dell reportedly converted 50% of final leads, against 17% for traditional methods. Price management based on customer lifetime value reportedly raised margins 2%–7% over 12 months and returned 200%–350% ROI. Apply the same logic to your own data: first, define the KPI (for example, revenue per customer). Second, standardize age and income and cluster customers with k-means into segments. Third, fit a linear regression for customer spend, check MAE and RMSE, and use Lasso to keep only the predictors that matter. Fourth, fit a churn classifier, rebalance with SMOTE if churners are rare, and read the drivers. Finally, concentrate budget on high-predicted-value segments and apply retention offers where churn drivers are strongest, and track the KPI against the baseline. The book's 17%-to-50% contrast is the benchmark for judging whether a targeted approach beats a traditional one; your own numbers must come from your data.

• If an attribute's values don't match business intuition, then investigate and clean (outliers, data quality) before modeling.
• If a segment can't be described in plain business terms, then change the number of clusters or the features and re-evaluate before presenting it.
• If a regression has many weak predictors, then apply Lasso to select features; if trends are non-linear, then compare against a tree-based or random forest model using MAE/RMSE.
• If churners are a small minority, then do not trust accuracy; rebalance (e.g., SMOTE) and judge the model by the confusion matrix.
• If a recommendation has no KPI, action and expected ROI attached, then it is not yet an insight; do not allocate budget on it.

• Modeling on unvetted data: the tell is outputs that contradict intuition or contain extreme values nobody explained.
• Segments that are statistically separable but not actionable: the tell is that the marketing team can't say what to do differently for each group.
• Reporting high accuracy on imbalanced churn data: the tell is a good headline score but few or no churners caught in the confusion matrix.
• Treating correlation as a driver: the tell is a recommended action based on a predictor-outcome relationship that was only seen in a plot or correlation, with no check of the model's coefficients or importances.
• Predictions with no resource decision: the tell is a report of predicted values or churn scores that does not change who is targeted or how budget is split.

• ▸Business question: the decision this analysis must inform.
• ▸KPI and baseline: the target metric and its current value.
• ▸Data checks done: outliers found, values that failed the intuition test and how they were resolved.
• ▸Segments: name, size and one-sentence business profile for each cluster.
• ▸Predicted value method and error: model used, MAE/RMSE, features retained.
• ▸Churn drivers: top drivers from the classifier and the evidence for each.
• ▸Imbalance handling and model check: sampling method used and confusion matrix findings for the minority class.
• ▸Targeted action per segment: the offer or treatment, tied to a driver.
• ▸Budget allocation and expected ROI effect: where resources go, priority order, and the KPI result that will confirm it.

1. 1Build the data model first: list every source, how it relates to the others, where it enters the pipeline, and its form (Excel file, database, or JSON from an internet source). Update this list as sources and processes change.
2. 2Classify each source as structured, semi-structured, or unstructured. Structured = flat table, correct value in correct attribute, a unique index, no duplicate columns. Semi-structured = fixed schema, possibly nested, with possible duplicate rows and missing values. Unstructured = arbitrary column counts, mismatched attributes, values leaking into other fields.
3. 3Write a structure-enforcing Python script at the pipeline entry point so the right value lands in the right attribute. The target is to move unstructured sources to at least semi-structured. Treat any value of the wrong kind as a bug to investigate, not something to pass through.
4. 4Flatten the semi-structured data into tables with no nesting or hierarchy, so each data point can be compared with the others in the common fields. Load it into pandas DataFrames.
5. 5Inspect the DataFrame with info() (index, datatype, memory) and describe() (descriptive summary statistics). Check that each column's datatype matches its meaning.
6. 6Handle missing values explicitly, because semi-structured rows may lack values for some attributes. Check where gaps occur, then decide per attribute whether to drop or fill. For plots, drop NaNs explicitly, as in sales['Gross profit'].dropna().
7. 7Compare the summaries with your business expectations, expressed as KPIs. If a value does not make intuitive sense, dig into why the attribute has it, and remove outliers once you understand them.
8. 8Visualize before modeling: boxplots by year for Revenue, Planned Revenue, Quantity, and Gross Profit, and histograms via seaborn. Only then start model creation or feature engineering, and clean the engineered features again so the model trains on high-quality data.

The source's sales dataset has Revenue, Planned Revenue, Quantity, and Gross Profit across 2004 to 2007. You load it into a pandas DataFrame, run info() and describe(), and compare the numbers with what the business expects. Then you draw boxplots per year (2004 to 2007, with 2005, 2006, and 2007 shown separately) to see whether any year's values break from the rest. Gross Profit contains missing values, so you call dropna() on that column and plot a histogram with sns.distplot(sales['Gross profit'].dropna(), kde=False). Any value that looks wrong against the KPI expectations gets investigated, and genuine outliers are removed, before any model is built. Skipping this step risks inaccurate models, models built on the wrong data, and wasted resources.

• If a source is Excel, CSV, or text with arbitrary columns or values leaking across fields, then treat it as unstructured and put a structure-enforcing script in front of it before analysis.
• If a value does not intuitively match business expectations or KPIs, then investigate why the attribute has it before removing it or modeling on it.
• If rows have missing values in an attribute, then drop or fill them deliberately and visibly (for example dropna() before plotting) rather than letting them pass silently.
• If the data is still nested or hierarchical after the checks, then flatten it into a table with one correct value per attribute before comparing data points.
• If you create features for a model, then clean those features again before training, because transformation can introduce new bad values.

• Passing mixed structured, semi-structured, and unstructured sources straight into the model; the tell is a single garbage value in one attribute throwing off the whole analysis.
• Stopping at semi-structured data and treating it as analysis-ready; the tell is nested fields and duplicate rows that make cross-point comparison in common fields impossible.
• Removing outliers without understanding them; the tell is that you cannot say why the attribute had those values.
• Skipping KPI comparison and trusting the numbers by default; the tell is that summaries disagree with business expectations and nobody has noticed.
• Cleaning the raw data but not the engineered features; the tell is a model trained on bad values created during feature transformation.

• ▸Source name and form: name the source and its format (Excel, database, JSON, CSV).
• ▸Structure class: record structured, semi-structured, or unstructured, and why.
• ▸Entry point: state where the source enters the pipeline.
• ▸Enforcement check: describe the script rule that ensures the right value goes in the right attribute.
• ▸Flattening needed: note any nesting or hierarchy to remove, and any duplicate rows.
• ▸Missing values: list the attributes with gaps and the drop-or-fill decision for each.
• ▸KPI expectation: state the target metric and the value you expect to see.
• ▸Outliers found: list the values that don't make intuitive sense and the explanation you found.
• ▸Sign-off: confirm info(), describe(), and plots were checked before modeling.

1. 1Define the outcome and its prediction window first. The source's example is a customer's spend for the next year. You need two historical periods: an earlier one to compute features and a later one where the outcome is already known.
2. 2List candidate features from the transactions using both data expertise and domain knowledge. Ask what the data can produce and what plausibly drives the outcome. The passages name three starting features: the number of purchases previously made, the amount spent, and the time since the last order.
3. 3Compute each feature only from the earlier period and attach it to the outcome from the later period, keyed by customer. The model then learns from earlier-period features to later-period outcomes. Once trained, it can score features built from today's data to predict a future period.
4. 4Clean while you create. Problems show up as you build features, so inspect each new feature as you go. For missing values, remove those rows if that makes sense. Otherwise insert the average or median of the other data points.
5. 5Check outliers on every feature. The source's standard definition is any point more than three standard deviations above the median. Look at a histogram, then default to removing the points. They can distort a model out of proportion to how rare they are.
6. 6Assess each feature before modeling. Look for relationships between the feature and the outcome using visualizations and correlations. You can also test how much the feature changes model performance and then decide whether to keep it.
7. 7Sanity-check values against business expectations. If a value doesn't make intuitive sense, dig into why the attribute has it before building on it. Where useful, change representation, for example turning numeric values into categories or the reverse, so the signal is clearer and not buried in detail such as floating-point precision.
8. 8Keep the pipeline structured. Enforce checks so the right value lands in the right field, and flatten data into tables so each data point can be compared across common fields.

The source's Exercise 20 starts from historical transaction data from 2010 and 2011, with a customer identifier on each transaction. The goal is to predict a customer's later spend from earlier behavior. Following the source's two-period logic, you split the data into an earlier window, used to compute features, and a later window, where spend is already known and becomes the outcome. From the earlier window you build one row per customer with the features the source names: number of previous purchases, total amount spent, and time since the last order. While building them, you check each for missing values and outliers. A customer with spend more than three standard deviations above the median is a candidate for removal, because it may not reflect normal behavior. You then plot each feature against later spend and check correlations, as in Exercise 21, to see which features relate to the outcome. The cleaned feature table feeds the linear model in Exercise 22. Only passages for the exercise's setup are available here, so the specific values and the final feature set are not stated.

• If a feature would need data from the outcome period, then drop it or recompute it from the earlier period. Features must come only from before the outcome.
• If a row is missing a value and removing it is reasonable, then remove it. If not, then fill in the average or median of the other data points.
• If a value lies more than three standard deviations above the median, then treat it as an outlier. Check it in a histogram and default to removing it, because it can have a disproportionate effect on the model.
• If a feature shows no relationship with the outcome in plots or correlations and does not improve model performance, then exclude it.
• If a value doesn't make intuitive sense against business expectations, then investigate before modeling. Don't build on data you can't explain.

• Building features and outcome from the same period. The tell is a model that looks accurate on history but has no earlier-to-later structure to predict a future period.
• Cleaning as a separate step after the features are done. The tell is odd values that surface only at modeling time, because problems should have been caught during feature creation.
• Leaving outliers in. The tell is a histogram with an extreme value and a fit pulled toward a few customers who don't reflect normal behavior.
• Keeping features by habit and never assessing them. The tell is a long feature list with no recorded relationship to the outcome and no test of its effect on model performance.
• Accepting values that don't make sense. The tell is a summary statistic that contradicts business expectations and goes unexplained, which risks a model built on the wrong data.

• ▸Outcome and window: name the outcome (e.g., next-year spend) and the later period where it is known.
• ▸Feature period: state the earlier period used to compute features, and confirm it does not overlap the outcome period.
• ▸Feature definition: write the feature and its rationale (e.g., purchase count, total spent, time since last order).
• ▸Missing-data handling: record how many values are missing and whether you removed them or filled with the average or median.
• ▸Outlier check: note the threshold used (more than three standard deviations above the median), the count flagged, and the action taken.
• ▸Relationship to outcome: record the correlation or plot finding between this feature and the outcome.
• ▸Model impact: record whether including the feature changes model performance.
• ▸Business sanity check: state whether the values match business expectations; if not, note what you investigated.
• ▸Decision: keep, transform, or drop, with one line of reasoning.

1. 1Fix the outcome first. In the book's Chapter 5 example it is '2011 revenue', and every candidate feature is judged by its relationship to that column, not by how interesting it looks.
2. 2Build the candidate list from engineered features, then clean it. The book creates features from transaction data (for example 2010 revenue, days_since_last_purchase, number_of_purchases, avg_order_cost, days_since_first_purchase) and loads them with CustomerID as the index.
3. 3Run a first filter with df.corr() and visual checks. Read the outcome's row of the correlation matrix and flag predictors with only a weak relationship to the outcome.
4. 4Drop the weak predictors explicitly and write down why. Then put the survivors in X and the outcome in y, for example X = df[[...four columns...]] and y = df['2011 revenue'].
5. 5Split before you judge the model. Use train_test_split(X, y, random_state=100) so the selected feature set is assessed on rows the model never trained on. The default split is 75% train and 25% test, adjustable with test_size.
6. 6Fit the model and read the coefficients in X-column order (model.coef_ with model.intercept_). Check that each sign and size makes business sense. A feature with a near-zero or implausible coefficient is a candidate to cut.
7. 7When the candidate list is too large or too correlated to filter by eye, use a model-based selector. Lasso regression (Chapter 6, Exercise 24; Activity 11 applies it to customer spend) shrinks uninformative coefficients, so the features it keeps are your selection. Tree-based models (Random Forests, Chapter 6) offer importance scores as a second opinion.
8. 8Select first, then scale. The book places scaling after feature selection (Exercise 39, 'Scaling Data After Feature Selection'), so the scaler never sees columns you discard. In classification (Exercise 33, then Exercise 34) the same order holds: select, then build the logistic regression.

Chapter 5, Exercise 22 builds a model that predicts customer spend from wrangled_transactions.csv, indexed by CustomerID. You call df.corr() and recall that days_since_first_purchase has only a weak relationship with 2011 revenue, so you leave it out. You keep four predictors: 2010 revenue, days_since_last_purchase, number_of_purchases and avg_order_cost. You split with random_state=100 and fit LinearRegression on the training portion. The coefficients are 4.14, -1.66, 394.96 and -0.49, with an intercept of 538.74. That gives 2011 revenue = 538.74 + 4.14*(2010 revenue) - 1.66*(days_since_last_purchase) + 394.96*(number_of_purchases) - 0.49*(avg_order_cost). You then predict for a new customer with 2010 revenue 1,000, 20 days since the last purchase, 2 purchases and an average order cost of 500. The selection step is the quiet correlation check that removed one column before any model was fit. The equation stays short enough to read and explain.

• If a candidate's correlation with the outcome is weak, drop it before modeling, as the book does with days_since_first_purchase.
• If you have many correlated or marginal predictors, use lasso (Exercise 24) to let coefficients shrink to zero rather than choosing by hand.
• If you suspect non-linear relationships, check tree-based or Random Forest importance, because a linear correlation can understate a feature's value.
• If you need to scale or standardize, do it after selection (Exercise 39), and only on the retained columns.
• If a smaller feature set is no worse on held-out test data, keep the smaller set.

• Choosing features on the full dataset and then splitting. The tell: test performance looks better than it does on genuinely new data, because the test rows influenced the selection.
• Relying on linear correlation alone. The tell: a feature with a weak correlation is dropped, yet a tree-based model on the same data finds it useful.
• Reading coefficients as importance when features sit on different scales. The tell: a huge coefficient like 394.96 on number_of_purchases next to -0.49 on avg_order_cost, with no check of the units behind each.
• Dropping a column without recording why. The tell: nobody can explain later why days_since_first_purchase was missing from X.
• Scaling before selecting. The tell: the scaler is fit on columns that are later discarded, and the pipeline order differs from the select-then-scale sequence in Exercise 39.

• ▸Outcome variable: name the single column you are predicting.
• ▸Candidate features: list every engineered column considered.
• ▸Correlation with outcome: record the df.corr() value for each candidate.
• ▸Method used: filter by correlation, lasso, or tree-based importance.
• ▸Features dropped and reason: one line each, citing the evidence.
• ▸Features kept (X list): the final columns, in order.
• ▸Split settings: test_size and random_state used for the held-out set.
• ▸Coefficient or importance check: note sign and size per kept feature and whether each is plausible.
• ▸Scaling step: confirm it was applied after selection, and on which columns.

1. 1Define 'similar' first. Pick features tied to the campaign you plan to run, and give each roughly equal importance in your mind. Customer behavior (past campaign responses) is the best input; income and age are the fallback when behavior data is absent.
2. 2Check the raw scales before touching anything. Compare the means and spreads of each continuous feature. If one feature's values are much higher than the others, it will dominate the objective function or the distance, and the estimator may not learn from the rest.
3. 3Match the method to the algorithm. Use standardization (mean 0, variance 1) for linear models and gradient-descent optimization, such as logistic and linear regression. Use min-max scaling (values mostly between 0 and 1) for Euclidean-distance methods such as KNN and k-means. Use normalization (each sample scaled to unit norm, L1 or L2) when you quantify sample similarity with a dot product or kernel, as in clustering and text classification.
4. 4Split first, then fit the scaler on training data only: `scaler = preprocessing.StandardScaler().fit(X_train[top5_features])`. Use `MinMaxScaler().fit(...)` or `MaxAbsScaler` for scaling.
5. 5Inspect what the scaler learned. For StandardScaler, read `scaler.mean_` and `scaler.scale_`. For MinMaxScaler, read `min_max.min_` and `min_max.scale_`. Confirm that the values match the units of each column.
6. 6Apply `transform` to both sets with the same fitted object: `scaler.transform(X_train[top5_features])` and `scaler.transform(X_test[top5_features])`. Never refit on the test set.
7. 7Compute distances or fit the model on the transformed arrays only. For clustering, run k-means on the standardized age and income, then explore the resulting groups.
8. 8Verify the result. Training columns should show a mean near 0 and a standard deviation near 1 after standardization, or fall between 0 and 1 after min-max scaling. Then compare model performance with and without scaling.

The source's bank churn exercise uses five features selected by random forest: Age, EstimatedSalary, CreditScore, Balance, and NumOfProducts. Their raw magnitudes differ widely. Balance and EstimatedSalary run far higher than NumOfProducts or Age, so left raw they would dominate a distance or an objective function. The exercise imports `from sklearn import preprocessing` and fits `StandardScaler` on `X_train[top5_features]`. It reads `scaler.mean_` (the five column means) and `scaler.scale_` (the five scaling values). It then calls `scaler.transform` on `X_train[top5_features]` and on `X_test[top5_features]`. The output is a train array centered at zero with unit variance, and the test set is scaled with the training statistics. Exercise 39 repeats the pattern with `MinMaxScaler`, checking `min_` and `scale_` and transforming both sets, which squeezes each feature toward the 0–1 range. For customer segmentation in Chapter 3, the same logic applies to age and income. Income's larger numbers would otherwise swamp age in the distance between customers.

• If the model is linear (logistic or linear regression) or trained by gradient descent, then standardize to mean 0 and variance 1.
• If the algorithm relies on Euclidean distance (KNN, k-means), then scale features to a common range with MinMaxScaler or MaxAbsScaler, or standardize.
• If similarity is a dot product or kernel, as in text classification or clustering, then normalize each sample to unit norm (L1 or L2).
• If one feature's values are much larger than the others, then rescale before modeling. Otherwise it dominates and the other features go unlearned.
• If you have a train/test split, then fit the scaler on train only and reuse it on test.

• Clustering on raw age and income. The tell: clusters split almost entirely along income and age has no visible effect.
• Refitting the scaler on test data, so train and test use different statistics. The tell: `mean_` and `scale_` differ between the two fits, and identical raw values map to different scaled values.
• Using the wrong tool for the algorithm, such as sample-wise normalization when you needed per-feature standardization. The tell: feature columns still have very different spreads after the transform.
• Scaling features that carry unequal importance for the business goal. The tell: a feature irrelevant to the campaign shapes the segments as much as the relevant ones, so choose features before scaling.
• Reading scaled outputs as original units. The tell: segment profiles quote income values near 0 or 1 and are not mapped back to real values.

• ▸Algorithm: name the model or clustering method (k-means, KNN, logistic regression, SVM).
• ▸Features list: list each continuous feature and its business relevance to the campaign.
• ▸Raw range per feature: note min, max, and mean to expose magnitude gaps.
• ▸Dominant feature: name any feature whose values dwarf the rest.
• ▸Chosen method: standardization, min-max scaling, or normalization (L1/L2), with a one-line reason tied to the algorithm.
• ▸Scaler fitted on: confirm it was fit on training data only.
• ▸Learned parameters: record mean_/scale_ or min_/scale_ after fitting.
• ▸Post-transform check: confirm mean about 0 and variance about 1, or values within 0–1.
• ▸Applied to: confirm the same fitted scaler transformed both train and test.

1. 1Name the task first: grouping with no labels (clustering), predicting a number (regression), or predicting a category (classification). The book follows this split: Chapters 4 for clustering, 5 and 6 for regression, 7 to 9 for classification. The algorithm shortlist comes from the task, not from the data format.
2. 2For clustering, start with k-means because it scales very well. Choose k by visual inspection, the elbow method on the sum of squared errors, and the silhouette score. Standardize first, as Exercise 16 does by turning income and age into z_income and z_age.
3. 3Run mean-shift as the alternative when k-means may fit poorly. Mean-shift does not need a cluster count, but it needs a bandwidth, usually estimated from distances between nearby points via a quantile. It is computationally expensive and scales poorly to large datasets. Treat it as a different model of the data, not a free pass out of hyperparameter choice.
4. 4If the customer data mixes categorical and numeric columns, switch to k-modes (categorical) or k-prototypes (mixed). Plain k-means is not built for those features.
5. 5Compare clustering candidates on the same footing. Fit each on a training set, score on a held-out test set (Exercise 19, four_cols.csv), and compare silhouette scores for the best k-means against mean-shift (Exercise 18).
6. 6For regression, begin with linear regression after checking predictor-outcome relationships through visualizations and correlations. Move to tree-based models (random forests) when you need to capture non-linear trends. Use Lasso regularization when the problem is choosing among many features. Compare candidates on MAE and RMSE.
7. 7For classification, start with logistic regression as the interpretable baseline. Then fit SVM (kernel for linearly inseparable cases), decision tree, and random forest on the same data. Preprocess as each needs (standardization, scaling, normalization), validate with stratified k-fold, and tune.
8. 8Pick the winner on metrics matched to the problem: precision, recall, F1, and ROC for classification. Use multiclass metrics for multiclass problems. Handle class imbalance (e.g., SMOTE) before judging, because accuracy on imbalanced data misleads.

The source's clustering chapter gives a direct case. Exercise 16 clusters customers on age and income from ageinc.csv. You standardize both columns into z_income and z_age by subtracting the mean and dividing by the standard deviation. You then run mean-shift, using estimate_bandwidth to set how far each point looks for a denser area. The authors warn that this bandwidth, set through a quantile of nearby-point distances, is the same kind of choice as picking k, so mean-shift does not remove the tuning burden. They justify using it anyway because it is a different algorithm and will fit certain datasets better than k-means. Exercise 18 settles the question empirically: compute the silhouette score to pick the best k for k-means, then compare that result against the mean-shift output. Exercise 19 adds a train-test split so each algorithm is judged on how well it generalizes to unseen data. The choice comes from measured comparison, not preference.

• If the dataset is large and you need a fast, scalable clusterer, then start with k-means; mean-shift is computationally expensive and scales poorly.
• If you do not want to fix the cluster count in advance, then try mean-shift, but expect to choose a bandwidth (quantile) instead.
• If your clustering features include categorical or mixed types, then use k-modes or k-prototypes rather than k-means.
• If predictor-outcome relationships are non-linear or linear regression residuals show structure, then try tree-based regression (random forest); if you have many candidate features, use Lasso to select them.
• If the outcome is a category, then begin with logistic regression as a baseline and justify SVM, decision tree, or random forest only by measured gains on the same stratified folds and metrics.

• Treating mean-shift as 'no hyperparameter' clustering. The tell: you cannot explain how the bandwidth quantile was chosen, and results shift sharply when it changes.
• Running k-means or mean-shift on unstandardized variables such as raw income and age. The tell: clusters split almost entirely along the largest-scale feature.
• Choosing an algorithm by familiarity and never comparing. The tell: only one model was fit, with no silhouette comparison, no MAE/RMSE comparison, and no common test set.
• Judging classifiers on accuracy when classes are imbalanced. The tell: high accuracy but low recall on the minority class; the book's remedy is to check precision, recall, F1, ROC, and use resampling such as SMOTE.
• Comparing models on different splits or preprocessing. The tell: a model 'wins' but the train-test split, scaling, or folds differed from the competitors'.

• ▸Task type: clustering, regression, or classification, and the business question in one line.
• ▸Data structure: numeric, categorical, or mixed features; row count; linear or non-linear relationships observed.
• ▸Preprocessing applied: standardization, scaling, or normalization, and why.
• ▸Baseline algorithm: k-means, linear regression, or logistic regression, plus the hyperparameter chosen and how.
• ▸Alternative algorithm(s): mean-shift, k-prototypes, random forest, SVM, or decision tree, and the structural reason each is a candidate.
• ▸Hyperparameter method: elbow, bandwidth quantile, Lasso penalty, or tuning grid, with the value selected.
• ▸Evaluation split: train-test or stratified k-fold details, identical across all candidates.
• ▸Metric results: silhouette, MAE/RMSE, or precision/recall/F1/ROC for each candidate.
• ▸Decision and rationale: chosen algorithm and the measured reason it beats the others.