01 · The big picture

AI creates value only when an output improves a decision

Artificial intelligence is the broad goal of building systems that perform tasks associated with human intelligence. Machine learning is a major approach: instead of writing every rule by hand, we estimate patterns from examples.

A business prediction connects information available now to an outcome that will be observed later. A retailer forecasts demand to set inventory; a bank estimates default risk to prioritize review; a subscription company estimates churn risk to target outreach. The prediction itself is not the final product. It becomes useful only when a person or system can take a sensible action and later measure the result.

Generative AI is another part of the larger AI landscape. It produces new language, images, code, or other content from learned patterns. This course first studies data-driven prediction, where inputs, targets, and errors are comparatively easy to inspect. It then studies language models and the systems, tools, evidence, and controls that make them useful in organizations.

02 · First data model

A dataset is a collection of examples

Think of each row as one example the model can learn from. A row might be one customer, one loan, one transaction, one company-year, or one sentence. The columns describe that example.

An observation is the unit represented by a row. A feature is information available about that observation before the prediction is made. The target is the outcome we want to predict. An identifier—such as customer ID—helps us locate a record but usually should not be treated as a meaningful feature.

The unit of observation must match the decision. If the decision is whether to approve a loan, one row should usually represent one loan application at the approval date. Mixing later information, such as whether the borrower eventually defaulted, into the features creates leakage: the model is accidentally allowed to see the future.

• Row: one observation or example.
• Feature, X: an input known when the decision is made.
• Target, Y: the outcome to predict or explain.
• Label: the observed target value in a supervised-learning dataset.
• Identifier: a tracking field, not automatically a predictive feature.

03 · Data vocabulary

Data types determine what preparation is sensible

Numbers are not all the same, and categories are not secretly numbers. A model must receive a representation that preserves the meaning of the original variable.

Numerical variables measure an amount. Continuous variables can take many values, such as revenue or temperature; discrete variables are counts, such as number of late payments. Categorical variables name groups, such as industry or payment method. Ordinal variables have an order—credit grades A through D—but the distance between neighboring levels is not necessarily equal.

Text, images, and timestamps are unstructured or specialized inputs that require feature extraction. A date may become day of week, quarter, time since last purchase, or a sequence. Missingness is also information: it can be random, caused by the process, or related to the outcome. Preparation choices should reflect that mechanism rather than applying one automatic recipe.

• Continuous: revenue, age, temperature, account balance.
• Discrete: number of complaints, transactions, or defaults.
• Nominal categorical: industry, country, product type—no natural order.
• Ordinal categorical: rating grade, satisfaction level—ordered categories.
• Binary: yes/no, fraud/not fraud, churn/stay.
• Text, image, and sequence data: require a numerical representation before modeling.

04 · Learning map

Supervised and unsupervised learning answer different questions

Supervised learning uses examples with known answers. Unsupervised learning looks for structure when no answer column is supplied.

In supervised learning, the training data include X and Y. Regression predicts a number, such as next-quarter sales. Classification predicts a class or probability, such as the probability of default. The word supervised does not mean a human watches every calculation; it means the examples contain target labels that supervise learning.

In unsupervised learning, the model receives X but no target Y. Clustering groups similar customers, dimensionality reduction summarizes many correlated variables, and anomaly detection identifies unusual observations. These results require interpretation: a cluster is a mathematical grouping, not automatically a meaningful customer segment.

Reinforcement learning is a third family. An agent chooses actions, receives rewards or penalties, and learns a policy over repeated interactions. It is useful for sequential decisions, but most tabular business prediction tasks in this course are supervised learning.

01 · Topic 5 · The learning problem

The model tries to learn the systematic part of an outcome

An outcome usually contains both a learnable pattern and uncertainty. Machine learning estimates the pattern; it cannot remove randomness or information that was never observed.

Let Y be the target and X the available features. The unknown function f describes the systematic relationship between them. The error term ε includes unobserved influences and randomness. A trained model is written as f-hat because it is an estimate learned from a finite sample, not the true relationship itself.

For a house-price model, X might include location, size, age, and condition. The same observable house can still sell at different prices because of negotiation, timing, buyer urgency, or omitted details. Better data and modeling may reduce prediction error, but irreducible uncertainty remains.

02 · Simplest fitted model

Linear regression chooses coefficients that make residuals small

A simple linear model draws the best-fitting line through observed examples. The intercept sets the starting level; each coefficient describes how the prediction changes when one feature changes and other included features are held fixed.

For one feature, the fitted prediction is β-hat-zero plus β-hat-one times X. A residual is the observed Y minus the fitted Y. Ordinary least squares selects coefficients that minimize the sum of squared residuals. Squaring prevents positive and negative errors from canceling and penalizes large misses more heavily.

A coefficient is an association inside the fitted model, not automatically a causal effect. If advertising rises when demand is already strong, a positive advertising coefficient can mix the effect of advertising with pre-existing demand. Prediction and causal explanation are different goals.

03 · Performance

Evaluate on new data, not the examples used to fit the model

A model that remembers the training sample can look excellent and still fail on new observations. The business objective is generalization.

Training error measures fit on the observations used to estimate the model. Test error measures performance on a held-out sample that represents future use. Flexibility usually lowers training error, but beyond a point it can increase test error because the model learns sample-specific noise.

High-bias models are too rigid and underfit: training and test errors are both high. High-variance models are too sensitive and overfit: training error is low, but test performance is unstable. The useful model is not the most complex; it is the model whose full pipeline performs reliably on representative unseen data.

04 · Read the plots

Residual plots reveal patterns that one average metric hides

A good residual plot looks like an unstructured cloud around zero; visible structure tells you what the model is missing.

In an actual-versus-predicted plot, the 45-degree line represents perfect prediction. Points far from the line have large errors. A residual-versus-predicted plot places each fitted value on the horizontal axis and its residual on the vertical axis. A curve suggests a missing nonlinear relationship; a funnel suggests the error variance changes with the level of the prediction; an isolated point may be an outlier or a data problem.

Residual plots are diagnostic, not decorative. Look at training and held-out data separately, color points by an important segment, and investigate errors in business units. A small average RMSE can coexist with systematically low forecasts for high-demand stores or a protected customer group.

01 · Classification output

The model estimates probability before it predicts a class

A default model should first say how likely default appears, not jump directly to yes or no. The action comes later.

A linear equation can produce values below zero or above one, so logistic regression passes a linear score through the logistic function. The result p(X) lies between zero and one. The log-odds form is linear, which makes the direction of coefficients interpretable.

If a borrower receives p = 0.18, the classification depends on the operating threshold. At a 0.50 threshold, the borrower is classified as non-default. At a 0.15 threshold, the same probability triggers review. The model output did not change; the decision rule did.

02 · Error vocabulary

The confusion matrix separates four outcomes

Correct predictions lie on the diagonal. The two off-diagonal cells are different mistakes with potentially very different business costs.

A true positive is a correctly flagged positive case; a true negative is a correctly cleared negative case. A false positive is a false alarm, also called a Type I error. A false negative is a missed positive, also called a Type II error.

Accuracy answers how often the model is correct overall. Precision asks whether positive alerts are credible. Recall, also called the true-positive rate or sensitivity, asks how many actual positives were found. Specificity asks how many actual negatives were correctly cleared. No single metric is always best.

03 · Threshold choice

Business costs determine the useful operating point

Lowering the threshold usually catches more positives, but it also creates more false alarms. The correct trade-off depends on what happens after an alert.

For medical screening or severe credit loss, a false negative may be especially costly, so the business may favor recall. For a limited investigation team, too many false positives can overwhelm capacity, so precision matters. Fairness, customer friction, regulation, and downstream controls also belong in the threshold decision.

An ROC curve plots true-positive rate against false-positive rate across thresholds. AUC summarizes ranking ability across the curve, but deployment still requires one operating threshold. A high AUC does not tell the organization which errors it can afford.

04 · Threshold curves

ROC traces sensitivity against false alarms across thresholds

One confusion matrix belongs to one threshold. An ROC curve summarizes what happens as the threshold moves from very strict to very permissive.

The ROC curve plots true-positive rate on the vertical axis and false-positive rate on the horizontal axis. Lowering the threshold usually catches more positives and also creates more false alarms. The top-left corner is desirable because it combines high recall with a low false-positive rate. A diagonal curve represents random ranking; a curve that bows toward the top left has useful separation.

ROC AUC summarizes ranking across all thresholds. It can be interpreted as the probability that a randomly chosen positive case receives a higher score than a randomly chosen negative case. AUC does not select the operating threshold, does not describe calibration, and can look reassuring when the positive class is rare. Precision–recall curves are often more revealing for rare fraud or failure because precision directly reflects the burden of false alerts.

01 · The central failure mode

Overfitting is a gap between remembering the sample and learning a durable pattern

An overfit model has very strong training performance but noticeably worse performance on new data.

Underfitting occurs when the model is too rigid or the features too weak to capture important structure; both training and validation performance are poor. Overfitting occurs when the model is flexible enough to chase noise, outliers, or accidental sample patterns; training error becomes very small while validation error rises. A useful model sits between these extremes.

Model complexity is not just the algorithm name. Polynomial degree, tree depth, minimum leaf size, number of selected variables, neural-network width, training duration, and prompt or retrieval choices can all increase flexibility. Compare training and validation curves as complexity changes and select using held-out evidence.

02 · Model selection

The final test set should be used once

Training data fit the model. Validation data choose among models. Test data estimate performance after all choices are locked.

If we repeatedly inspect test performance while changing features or hyperparameters, the test set becomes part of the training process. Its reported performance is then optimistic. A three-way split protects the final estimate: train on training data, tune on validation data, and evaluate once on the test data.

With limited data, K-fold cross-validation rotates the validation role. Split the training sample into K folds, fit on K−1 folds, validate on the remaining fold, repeat K times, and average the metric. The untouched final test set remains outside this loop.

03 · Complexity control

Regularization makes complexity carry a cost

Regularization discourages a model from using large or unstable coefficients unless they materially improve fit.

Lasso adds an L1 penalty, the sum of absolute coefficient values. It can set coefficients exactly to zero and therefore perform a form of feature selection. Ridge adds an L2 penalty, the sum of squared coefficients. It shrinks correlated predictors together rather than removing most of them.

The tuning parameter λ controls the trade-off. At λ = 0, the penalty disappears. As λ grows, the fitted model becomes simpler. Cross-validation chooses λ based on unseen-fold performance, not on which coefficient pattern looks most impressive.

04 · Complete workflow

Preparation belongs inside the validation process

Imputation, scaling, encoding, feature selection, and model fitting form one pipeline. Any step that learns from data must be fit only on the current training portion.

Imputation, scaling, encoding, feature selection, and model fitting form one pipeline. Any step that learns from data must be fit only on the current training portion. If an imputer or scaler sees the validation fold before model fitting, information has crossed the boundary and the score is optimistic.

A leakage-safe pipeline fits preprocessing on each training fold and applies those learned transformations to its validation fold. After model choice is locked, refit the entire pipeline on the development data and evaluate once on the untouched final test set.

01 · Step 1 · Frame

One row is one passenger; Survived is the binary target

Begin with the table’s meaning, not with code.

The target Survived equals 1 for a survivor and 0 otherwise. Candidate predictors include passenger class, sex, age, siblings or spouses aboard, parents or children aboard, fare, and embarkation port. PassengerId is an identifier. Name and ticket may contain useful patterns, but feature engineering from them should be documented and validated rather than added casually.

The teaching objective is predictive classification, not a causal statement about why one person survived. Historical social and operational conditions produced the labels. Any interpretation should acknowledge that the model describes patterns in this dataset.

02 · Step 2 · Audit

Inspect types, missingness, distributions, and group counts

Before filling missing values, ask where they occur and whether missingness itself carries information.

Create a data dictionary, count missing values, inspect the target balance, and compare numerical distributions by target. Cabin is missing for many passengers; Age is missing for a meaningful subset; Embarked has very few missing values. A missing-cabin indicator may capture whether cabin information was recorded, while raw Cabin may be too sparse for a first model.

Plot survival rate by passenger class and sex, age and fare distributions, and counts by embarkation port. These are descriptive patterns, not proof of causal effects. The audit also catches impossible ages, duplicate IDs, inconsistent category labels, and parsing problems.

03 · Step 3 · Split

Protect a stratified test set before learning preprocessing choices

The test set must represent unseen passengers and must not influence imputation, scaling, feature selection, or tuning.

Use a stratified split so the survival proportion is similar in development and test sets. Within the development set, use cross-validation for model and hyperparameter choices. Set a random seed for reproducibility and save row identifiers so predictions can be traced back during error analysis.

Do not calculate the median age or category frequencies on the full dataset. The pipeline must learn those values from each training fold and then apply them to the corresponding validation rows.

04 · Step 4 · Prepare

Numerical and categorical columns need different transformations

A column transformer keeps preprocessing attached to the model so validation remains honest.

For a transparent baseline, impute numerical features such as Age and Fare with training-set medians and optionally scale them for logistic regression or a neural network. Impute categorical features with the most frequent category or an explicit Missing level, then one-hot encode. Tree models do not require standardization, but they still require a defined missing-value and categorical strategy.

Fit the entire preprocessing-plus-model pipeline inside cross-validation. This makes deployment repeatable: a new passenger row goes through exactly the transformations learned during training.

05 · Steps 5–8 · Fit, compare, diagnose, communicate

Start simple, then justify every added model

A logistic baseline establishes what the data can do before flexibility is added.

Fit regularized logistic regression first. Compare a pruned decision tree, a tuned random forest, and a small neural network using the same folds and metrics. Choose the operating threshold from validation data when error costs matter; do not tune it on the final test set.

On the locked test set, report the confusion matrix, precision, recall, specificity, ROC AUC, and calibration. Inspect false positives and false negatives, compare results across major groups, document uncertainty, and explain which patterns are predictive rather than causal. A final recommendation should include limitations and the exact preprocessing pipeline.

01 · Topic 6 · Tree-based models

A tree partitions the feature space with questions

A decision tree repeatedly asks a yes-or-no question, such as ‘interest coverage below 2.0×?’ Each answer sends the observation down one branch until it reaches a leaf.

For regression, a leaf typically predicts the average target among training observations in that region. For classification, a leaf predicts a class probability or majority class. The model learns both the feature and threshold used at each split.

Recursive binary splitting is greedy. At each node, the algorithm chooses the available split that most improves the current objective. It does not search every possible future tree. A deep tree can create very pure leaves and still overfit because small changes in the sample may produce a different structure.

03 · Ensembles

Random forests average many decorrelated trees

A forest is not one very large tree. It is a collection of trees trained on different bootstrap samples and different subsets of candidate features.

Bagging draws many bootstrap datasets by sampling training observations with replacement. A tree is fit to each sample, and predictions are averaged or voted. Averaging reduces variance when the trees do not make exactly the same mistakes.

Random forests add feature randomness at each split. Preventing every tree from repeatedly choosing the same dominant predictor makes the trees less correlated and often improves the ensemble. Feature importance can help with exploration, but correlated variables can share or distort importance; it is not a causal ranking.

04 · Read the surfaces

Trees create rectangular regions; forests average many different partitions

A two-feature decision surface makes the model’s geometry visible.

Every tree split is a vertical or horizontal threshold in a two-feature plot. Repeating splits creates step-like rectangular regions. A deep tree can wrap tightly around individual training points, which is a visible form of overfitting. Limiting depth or minimum leaf size simplifies the surface.

A random forest fits many trees on resampled rows and random feature subsets, then averages their probabilities or votes. Individual trees remain irregular, but averaging usually produces a more stable surface. The forest is not automatically interpretable because hundreds of paths contribute to one prediction; use permutation importance and local explanations carefully and validate them.

01 · Topic 6 · Neural networks

A neuron forms a weighted score, then applies an activation

Each neuron combines its inputs, adds a bias, and passes the result through a function. ReLU returns zero for a negative score and the score itself for a positive score.

The weighted sum determines which inputs matter and in which direction. The activation function creates nonlinearity. Without nonlinear activations, stacking many linear layers would still collapse to one linear transformation.

A hidden neuron can be read as a learned feature. One unit might activate for high experience; another might activate only when experience and performance jointly cross a threshold. Later layers combine these features into progressively more useful representations.

02 · Fitting

Training changes weights in the direction that reduces loss

Gradient descent repeatedly measures how the loss changes with each parameter and takes a small step downhill.

Full-batch gradient descent uses the entire training set for each update. Stochastic gradient descent uses one observation; mini-batch training uses a small group and is the common compromise. The learning rate controls step size. Too large can overshoot; too small can learn very slowly.

Deep networks have enough flexibility to overfit. Validation-based early stopping ends training when unseen-fold performance stops improving. Dropout randomly turns off a fraction of hidden units during training so the network cannot rely too heavily on one pathway. Weight penalties and more representative data provide additional control.

03 · General workflow

Model choice is only one step in a controlled pipeline

Collect and clean the data, define the split, fit preprocessing on training data, tune with validation, refit the chosen pipeline, and evaluate once on unseen test data.

Neural networks often benefit from standardized numerical inputs because gradient-based optimization is sensitive to feature scale. Random forests usually do not require scaling because threshold splits are invariant to monotonic rescaling. Both still need sensible missing-value and categorical-variable handling.

Grid search evaluates a specified combination grid. Random search samples combinations and can cover a large space more efficiently. Bayesian optimization uses prior results to choose promising next trials. Whatever the search method, the final test sample must remain outside tuning.

01 · No answer column

Clustering asks which observations are similar

Classification learns from known labels. Clustering receives only features and searches for structure.

Suppose a retailer has customer recency, purchase frequency, average order value, discount use, and return rate, but no accepted segment labels. K-means can group customers whose feature profiles are close. It cannot tell us whether the groups are profitable, fair, durable, or responsive to a campaign. Those are later business questions.

The unit of observation still matters. One row might represent one customer measured at the same month-end date. Features should describe behavior available at that date. Customer ID should remain metadata because numerical ID proximity does not represent behavioral similarity.

02 · Assignment and update

K-means repeats two understandable steps

Assign each point to its nearest centroid; then move each centroid to the mean of its assigned points. Repeat until assignments stop changing or improvement becomes negligible.

1. Choose the number of clusters, K, and initialize K centroids.
2. Measure the distance from every observation to every centroid.
3. Assign each observation to its nearest centroid.
4. Recompute each centroid as the feature-by-feature mean of its assigned observations.
5. Repeat assignment and updating until the solution converges.

The objective prefers compact groups, which is why K-means works best when clusters are reasonably round and comparable in size. Different initial centroids can lead to different local solutions, so practical software uses K-means++ initialization and multiple reruns.

03 · Inputs determine the geometry

Feature choices and units can change the answer

Distance gives every included feature a vote. A feature measured on a much larger numerical scale can take over the election.

If annual spending ranges from $50 to $50,000 while purchase frequency ranges from 1 to 20, raw Euclidean distance will be dominated by dollars. Standardization places features on comparable scales. It does not make every feature equally meaningful; analysts still decide which variables belong in the segmentation.

RFM features—recency, frequency, and monetary value—offer a common starting point. Recency should be oriented carefully because a smaller number of days may indicate greater engagement. Highly redundant features, extreme outliers, identifiers, and arbitrary category codes can distort the geometry.

Here, \(a(i)\) is the average distance from observation \(i\) to its own cluster, while \(b(i)\) is its smallest average distance to another cluster. Values near 1 indicate a well-matched observation, values near 0 indicate a boundary case, and negative values suggest that another cluster may fit better. The highest average silhouette is evidence—not an automatic business answer.

04 · Interpretation after estimation

A cluster becomes a segment only after profiling and testing

Never name clusters before inspecting their centroid values, member distributions, size, stability, and operational relevance.

Profile each group with meaningful summaries: median recency, order frequency, spending, return behavior, channel mix, and customer count. Neutral labels such as Cluster 1 are safer during analysis. Descriptive names such as “frequent low-ticket buyers” should follow the evidence and remain provisional.

Then ask whether the grouping changes a real decision. A useful segment should support a differentiated product, service, communication, or test. Compare cluster solutions across random starts and time periods. If membership changes dramatically or no business team can act differently, the mathematically neat solution has little practical value.

• Separation: are clusters meaningfully distinct?
• Cohesion: are members of a cluster reasonably similar?
• Stability: do reruns, samples, and later periods produce comparable profiles?
• Actionability: can the organization do something different for the groups?
• Responsibility: could proxy variables create exclusion, stereotyping, or unfair treatment?

01 · Start with the decision

The model score is an input to a business action

A useful AI project begins with a repeated decision, not with a favorite algorithm.

For each use case, name the decision maker, the decision time, the available actions, and the outcome that arrives later. A churn model might rank accounts for retention outreach; a fraud model might route a transaction to approval, review, or decline; a demand forecast might determine an order quantity. These actions create different costs and constraints even when the model produces a probability in every case.

The prediction target must be observable and time-bounded. ‘Customer will churn’ is vague. ‘Active customer at month-end cancels within the next 30 days’ identifies the population, prediction date, and outcome window. This definition tells the analyst how to construct historical rows without leaking future information.

02 · Task families

Common business problems reuse a small set of learning patterns

The business language changes, but the statistical task often repeats.

Churn, fraud, late payment, and equipment failure are usually classification problems. Sales volume, delivery time, and energy usage are regression or time-series forecasting problems. Recommendations are commonly ranking problems: the system orders products or actions rather than predicting only one label. Customer segmentation is unsupervised and must be judged by stability and usefulness, not by an accuracy score against labels that do not exist.

Prediction and causality are different. A model can identify customers likely to leave without showing that a discount will prevent departure. The targeting question ‘who is high risk?’ is predictive; the intervention question ‘who will remain because of this offer?’ is causal. A business workflow should not silently substitute the first answer for the second.

03 · Metrics and constraints

Evaluate at the point where the organization acts

The best metric depends on what the organization can do with the ranking or forecast.

If a retention team can contact only 1,000 customers, precision among the top 1,000 and incremental retention value may matter more than accuracy across every customer. For rare fraud, recall, false-positive workload, and dollars prevented are more informative than raw accuracy. For demand, forecast bias matters because consistently ordering too much and consistently ordering too little create different operating failures.

A complete scorecard includes model quality, business outcome, workload, fairness, latency, and cost. Always compare against a simple baseline: last period, a rule already used by staff, or a regularized linear model. Complexity is justified only when it improves the protected decision metric and remains operable.

01 · Part A: frame the task

Write the decision before choosing a model

A useful prediction project specifies who acts, when they act, what information exists at that moment, what future outcome is measured, and how the output changes the decision.

“Predict stocks” is too vague to build or evaluate. A usable specification might be: for each stock at the close of trading day \(t\), estimate the probability that its close-to-close return on day \(t+1\) is positive, using only information published by the close on day \(t\), then rank a defined investable universe. That sentence defines the observation, decision time, target window, information cutoff, model output, and action format.

The evaluation must match the action. A ranking strategy needs performance among selected securities, turnover, costs, risk, and stability—not only overall directional accuracy. A forecast used for inventory or staffing would require different error costs and operating measures.

A prediction is not automatically causal. A model may identify high-risk or high-return cases without showing that an intervention causes a better outcome. Keep “what is likely?” separate from “what will happen because we act?”

02 · Part B: target and baseline

A stock project needs a horizon, information cutoff, and baseline

‘Predict the stock market’ is not a modeling target. ‘Predict whether tomorrow’s close-to-close return is positive using information available by today’s close’ is testable.

Targets might be next-day return, next-month volatility, earnings-surprise direction, or a cross-sectional ranking of firms. Each choice changes the observation unit and the realistic information set. Predicting price levels can look accurate simply because today’s price is close to tomorrow’s; predicting returns exposes how little incremental signal the model may contain.

Baselines include zero return, the historical mean, a random-walk price forecast, and a simple linear or logistic model. Report out-of-sample improvement over the baseline, not a graph that visually hugs the price series. A model that cannot beat a naive chronological baseline has not earned operational complexity.

03 · Time-aware validation

Random train-test splits can leak future regimes into the past

In time series, validation must preserve the order in which information became available.

A walk-forward test trains on an initial history, predicts the next period, expands or rolls the training window, and repeats. Feature construction must also respect time. A revised macroeconomic series, a final quarterly value published weeks later, or a full-sample normalization can leak future knowledge even when the rows themselves are ordered.

Markets adapt. A relationship estimated during low rates may fail during inflation; a profitable signal can weaken after adoption; liquidity and transaction cost change across securities. Evaluate by subperiod, report turnover and costs, and separate model selection data from a final untouched time block.

04 · Two meanings of prediction

Prediction markets aggregate beliefs; ML models estimate patterns

A prediction market price is an equilibrium produced by traders, while a predictive model is a fitted mapping from features to an outcome.

In a simple binary contract that pays $1 if an event occurs, a price of $0.62 is often interpreted as roughly a 62% market-implied probability under simplifying assumptions. The price also reflects liquidity, fees, risk preferences, rules, and who can participate, so it is not pure truth.

Prediction markets can become an input or baseline for an ML system, and ML forecasts can inform traders. But the two should not be confused. One aggregates incentives and beliefs through trading; the other learns from a dataset under a specified loss function. Both require calibration checks and clear event definitions.

01 · Topic 8 · NLP

Tokenization decides what the model is allowed to treat as a unit

Text must be broken into tokens before it becomes numbers. A token might be a word, punctuation mark, or subword fragment.

A vocabulary assigns an index to each token. One-hot encoding represents one token with a vector containing a single one and zeros elsewhere. It preserves identity but says nothing about similarity: ‘loan’ and ‘credit’ are as unrelated as ‘loan’ and ‘banana.’

Tokenization choices affect unknown words, misspellings, company names, numbers, and languages. Modern systems often use subwords so uncommon words can be assembled from familiar pieces. Preprocessing should preserve information needed by the task rather than automatically deleting punctuation, negation, or capitalization.

02 · Sparse features

Bag-of-words counts tokens; TF–IDF discounts common ones

Bag-of-words turns each document into vocabulary counts. It is simple, inspectable, and often a strong baseline, but it ignores word order.

Term frequency measures how often a term appears in a document. Inverse document frequency gives less weight to terms appearing in many documents. TF–IDF is high when a term is frequent in one document but uncommon across the corpus.

The representation is sparse because most documents use only a small portion of the vocabulary. A linear classifier on TF–IDF can work well for sentiment or disclosure classification and is easier to audit than a deep model. It still cannot understand context or the difference between ‘not good’ and ‘good’ unless the feature design captures phrases.

03 · Dense features

Embeddings place related words near one another

A word embedding is a compact numerical vector learned from patterns of word use. Similar contexts produce nearby vectors.

Word2Vec learns static embeddings by predicting a word from its context or context from a word. Dense vectors can encode useful relationships and provide far fewer dimensions than a one-hot vocabulary.

Static means one vector per token. The word ‘bank’ receives the same vector in ‘river bank’ and ‘bank loan.’ That limitation motivates contextual embeddings: the representation should depend on the surrounding sentence.

04 · Twitter/X sentiment case

A sentiment score is a measurement pipeline, not public opinion itself

Social posts can become business signals, but the result depends on collection, cleaning, labeling, aggregation, and validation choices.

A basic pipeline collects posts under a documented query and time window, removes duplicates and obvious spam, preserves negation and useful punctuation, scores each post, and aggregates scores by day or week. VADER is a lexicon-and-rule baseline designed for social text; TF–IDF with logistic regression learns task-specific word weights from labels; BERT-style classifiers use context. Begin with the simplest baseline that can be audited.

Posts are not a random sample of customers or investors. A few viral messages, coordinated accounts, bots, sarcasm, changing platform policies, and event-driven volume can dominate an average. Report post count, score distribution, and alternative aggregation choices. If engagement weights are used, show both weighted and unweighted results so popularity does not silently become sentiment.

01 · Contextual embeddings

The same token should move when its context changes

The vector for ‘bank’ should become nature-related in ‘river fishing bank’ and finance-related in ‘money deposit bank.’ Self-attention performs that context-dependent update.

Each token begins with an embedding. Positional encoding adds information about where it appears, because attention alone sees a set of vectors rather than an ordered sentence. The model then creates query, key, and value vectors for every position.

A query represents what the current token is looking for. Keys describe what each token can match on. Values contain the information that will be mixed. The query–key dot product produces a similarity score; scaling stabilizes it; softmax converts scores to weights that sum to one; the weighted sum of values becomes the updated representation.

02 · Architecture map

Attention is one operation inside a repeated transformer block

The large diagram is a map, not a formula to memorize. Read it from the embeddings at the bottom toward the prediction at the top.

The original Transformer has an encoder stack on the left and a decoder stack on the right. The encoder turns the input tokens into contextual representations. The decoder uses masked self-attention so that a position cannot look at future output tokens, cross-attention to read the encoder output, and a final linear layer to produce token scores.

Inside each block, attention moves information between token positions, while the feed-forward network transforms each position. Residual additions preserve an earlier representation, and normalization helps keep the repeated updates stable. Modern language models may use only the encoder side, only the decoder side, or a related variant, but these building blocks are still the useful starting vocabulary.

04 · Business meaning

Context matters whenever the same term has multiple operational meanings

Customer reviews, contracts, search queries, support tickets, and earnings calls repeatedly reuse ambiguous words.

‘Charge’ can mean a price, an accusation, an electrical state, or a payment-card transaction. A static vector blends those meanings. Self-attention can route information from nearby words such as fee, criminal, battery, or card to create a context-specific representation.

The representation can then support classification, retrieval, extraction, or generation. The model still needs task-specific evaluation because contextual understanding can fail on specialized terminology, long documents, numerical relationships, or unfamiliar domains.

01 · Topic 9 · BERT

BERT learns to represent text using context from both directions

BERT is primarily an encoder model. During masked-language-model pre-training, it predicts hidden tokens using words before and after the missing position.

Pre-training creates a general language representation from a large corpus. Fine-tuning then adjusts the model for a labeled task such as sentiment classification, search relevance, or recommendation. Special tokens and a task-specific output layer help convert the general encoder into a classifier.

Bidirectional context is valuable when the entire input is available at once. BERT is not naturally designed to generate long passages token by token. Its strength is understanding and representing supplied text.

02 · Topic 9 · GPT

GPT predicts the next token and can generate fluent sequences

GPT is primarily a decoder-style autoregressive model. It predicts each next token from the tokens that came before it.

The next-token objective produces a powerful generator, but the model is optimized for plausible continuation—not for checking a corporate filing, proving a calculation, or admitting that evidence is missing. A fluent answer can therefore contain unsupported facts, invented citations, or confident numerical errors.

Few-shot examples, clearer instructions, tool use, structured outputs, and verification can improve reliability. None guarantees truth. The control must match the failure: retrieval helps missing knowledge; calculators help arithmetic; source citations help auditability; abstention rules help when evidence is absent.

03 · Grounding

RAG retrieves evidence before the model writes

Retrieval-augmented generation connects an LLM to an external collection of documents. The response is conditioned on passages retrieved for the current question.

A RAG system splits documents into chunks, embeds and indexes them, retrieves candidates for a query, optionally reranks them, and supplies selected passages to the generator. In valuation, the collection might contain 10-K, 10-Q, earnings-release, and call-transcript excerpts.

Evaluation must separate retrieval and generation. If the correct passage was never retrieved, a better writing prompt cannot recover it. If the correct passage was retrieved but the answer misstates it, the generation or instruction layer failed. Source coverage, citation accuracy, answer faithfulness, and abstention behavior should be tested independently.

01 · Prompt anatomy

A strong prompt names the instruction, input, context, and output contract

The model should know what to do, what material to use, what boundaries apply, and what a successful response looks like.

The instruction names one deliverable and its purpose. Input data are separated clearly from instructions. Context supplies audience, definitions, source boundaries, and the decision date. The output indicator specifies a schema, length, units, or rubric. Constraints explain what not to infer and what to do when information is missing.

Role prompting can supply a useful perspective—such as ‘you are a service-desk analyst writing for nontechnical employees’—but it does not create expertise or permission. Concrete task details and source evidence matter more than an impressive job title in the prompt.

02 · Zero-shot and few-shot

Examples teach boundaries and format, not permanent new knowledge

Zero-shot gives instructions without demonstrations; few-shot adds a small set of input-output examples inside the prompt.

Use zero-shot first when the task and output can be stated clearly. Add few-shot examples when the model repeatedly misreads labels, tone, edge cases, or formatting. Examples should be representative, diverse, and correct. Include difficult boundaries rather than three nearly identical easy cases.

Few-shot prompting changes the immediate context; it does not retrain the model. A demonstration can also introduce bias. If every example labels complaints as urgent, the model may imitate that pattern. Keep a separate evaluation set so improvements are measured on cases the prompt examples did not reveal.

03 · Reasoning-aware prompting

Ask for decomposition, evidence, and checks—not an unverifiable performance of thought

Complex tasks benefit from a plan and intermediate artifacts, but the final work should be reviewable without depending on hidden model reasoning.

Useful patterns include ‘extract the facts, then classify,’ ‘calculate with the supplied formula, then run a consistency check,’ and ‘draft, critique against the rubric, then revise.’ For business use, request cited evidence, assumptions, calculations, and a concise justification. Do not treat a long explanation as proof that the answer is correct.

Prompt chains separate jobs with different error modes. One stage can classify support tickets into a fixed schema; a second retrieves the policy; a third drafts a response; a deterministic check verifies required fields. Version the prompt and compare versions on the same evaluation set.

01 · What changes

Reasoning models spend more inference work on difficult tasks

They are designed to handle multi-step problems by doing more internal work before producing the answer.

Reasoning is especially useful when the task contains interacting constraints, several dependent steps, tool selection, ambiguous evidence, or a need to recover after an unsuccessful attempt. Examples include planning a data migration, reconciling contradictory policy documents, debugging a workflow, or comparing several operational scenarios.

More reasoning is not automatically better. A simple classification or retrieval request may need low latency and a fixed schema, not extended exploration. Choose the model and reasoning setting with an evaluation set, then compare task success, required evidence, latency, tokens, and cost. The right setting is workload-specific.

02 · Plan–act–observe–check

A useful workflow alternates model judgment with verifiable operations

The model can decide what information is needed, a tool can obtain it, and a check can determine whether the result satisfies the task.

Planning breaks the objective into a short sequence with dependencies and stopping conditions. Acting may call search, a database, a calculator, or a business API. Observation brings the tool result back into context. Checking compares the accumulated artifact with requirements and may trigger a correction or a request for missing information.

The visible deliverable should contain the answer, evidence, calculations, assumptions, and unresolved issues needed for review. A user does not need access to private internal chain-of-thought to assess quality. Long model narration can be persuasive and still wrong; reproducible evidence and deterministic checks are stronger controls.

03 · Tool choice

Language models coordinate tools that provide current data or exact operations

Use the model for semantic judgment and use tools for information or actions outside the model’s reliable memory.

Function calling lets an application describe available functions and their input schemas. The model may request a function, the application executes it, and the result is returned to the model. Useful tools include customer lookup, inventory queries, policy search, calculators, code execution, and ticket creation. The model proposes the call; the surrounding application controls execution and permissions.

A tool does not guarantee correctness. Tool selection can be wrong, arguments can be malformed, results can be misunderstood, and side effects can be excessive. Validate arguments, expose only necessary functions, log calls and outputs, set retry and stopping limits, and require approval for sensitive or irreversible actions.

01 · Agent anatomy

An agent combines a model with an execution loop

The model selects a next step, but software owns the loop, tools, permissions, state, and stop conditions.

A practical agent has an objective and instructions, a model, a set of tools, temporary state, optional retrieved knowledge, guardrails, and a runner that repeats until completion or interruption. The agent can ask a clarifying question, call a tool, update its working state, hand control to a person, or produce a final artifact.

Not every LLM application is an agent. A one-shot summarizer and a fixed three-step extraction pipeline may be better described as model-powered workflows. Use an agent when the next step genuinely depends on what was learned during execution. Prefer deterministic sequencing when the process and branching rules are already known.

02 · State and memory

Different information stores solve different problems

Calling everything ‘memory’ hides important privacy, freshness, and correctness choices.

Conversation history records the current interaction. Workflow state tracks task-specific fields such as ticket ID, completed checks, approvals, and pending actions. RAG retrieves external knowledge from an approved source. Long-term memory stores selected facts across sessions. Each store needs an owner, retention policy, access rule, and update strategy.

More memory is not automatically helpful. Stale preferences, incorrect summaries, or sensitive information can pollute future decisions. Store only information with a defined future use; distinguish user-provided fact from model inference; allow correction and deletion; and retrieve the minimum relevant context for the current task.

04 · Reactive and proactive patterns

The trigger determines when the agent begins and how much autonomy it has

A reactive agent responds to a user or system event; a proactive agent monitors conditions and initiates work.

Reactive designs are easier to review because the trigger and requested outcome are explicit: a user submits a ticket, the agent investigates, and it returns a draft. Proactive designs might watch error logs and open an incident when thresholds are crossed. They require stricter scope, rate limits, notification rules, duplicate suppression, and escalation paths.

Autonomy should grow only after evidence. Start with read-only research and drafts, add low-risk actions with validation, and reserve irreversible or high-impact actions for approval. The best agent is not the one that does the most; it is the one whose authority matches its demonstrated reliability and business need.

01 · Why multiple agents

Specialization helps when work divides into genuinely distinct contexts

Different agents can carry different instructions and tools, but every boundary adds coordination cost.

A procurement project may separate technical requirements, security evidence, pricing, and implementation risk. A coordinator can dispatch these workstreams in parallel and synthesize a packet. Specialization reduces prompt clutter and can shorten wall-clock time when subtasks are independent.

Do not split one tightly coupled reasoning chain just to create an agent team. Agents can duplicate research, disagree about definitions, lose provenance during handoff, and amplify a false premise. Start with one agent and split only after evaluation reveals a context, tool, or concurrency bottleneck.

02 · Orchestration patterns

Managers retain control; handoffs transfer control

The pattern should match who owns the final answer and whether the next specialist is predictable.

In a manager pattern, one coordinating agent calls specialist agents as tools and remains responsible for the final response. In a handoff pattern, a triage agent transfers the run to a specialist, such as language-specific or product-specific support. Parallel specialists work independently and return artifacts to a synthesizer. A reviewer pattern sends a draft to a critic with a fixed rubric before revision.

Predefined workflows encode the sequence in software and are easiest to audit. Autonomous workflows let the model decide roles and routes but are harder to predict. Hybrid workflows keep stable stages in code while allowing bounded model decisions within a stage. For most business processes, hybrid control is a practical default.

03 · Role and state design

Every agent needs an input contract, output contract, and authority boundary

A role name is not enough; orchestration depends on explicit artifacts and ownership.

Define what each agent receives, which sources and tools it may use, the schema it returns, how uncertainty is represented, and what it may never do. Shared state should contain accepted facts, artifact versions, source links, decisions, and unresolved conflicts—not a large undifferentiated conversation transcript.

The synthesizer must preserve provenance and resolve conflicts rather than averaging them away. Stop conditions include completion of required artifacts, approval, budget or time limits, maximum handoffs, and explicit failure when mandatory evidence is absent. Evaluate each specialist and the end-to-end workflow.

01 · Risk is systemic

The same model can be low-risk or high-risk depending on data and action

Summarizing a public brochure is not the same system as changing payroll records, even if both use the same underlying model.

Map the purpose, users, affected people, data sources, model and vendor, retrieval collection, tools, permissions, outputs, decision owner, and fallback process. Then ask what can go wrong at each boundary. NIST’s AI Risk Management Framework organizes continuous work into govern, map, measure, and manage rather than treating governance as a one-time checklist.

Risk also depends on impact and reversibility. A draft for human review can tolerate different error rates than an automatic denial, external message, payment, or system change. High-impact uses need stronger evidence, logging, subgroup testing, red teaming, human review, and a non-AI fallback.

02 · Data and content risk

Privacy, leakage, confabulation, bias, and provenance need separate controls

‘The AI might be wrong’ is too broad to guide action. Name the failure and its pathway.

Privacy risk includes unauthorized disclosure, retention, re-identification, or use of personal and confidential information. Minimize inputs, classify data, redact when possible, restrict access, understand vendor retention and training terms, and document the authorized purpose. Do not paste sensitive business data into an unapproved service because the interface looks convenient.

Confabulation is confidently stated false content. Grounding, retrieval, citations, abstention, and verification reduce risk but do not eliminate it. Bias can enter through historical data, labels, representation, thresholds, and deployment. Intellectual-property and content-authenticity questions require source records, license or policy review, provenance labels, and clear ownership—not model confidence.

03 · Agentic security

Prompt injection becomes more dangerous when the model has tools

Untrusted content can contain instructions that try to redirect the agent, and excessive permissions can turn that mistake into an action.

A direct prompt injection comes from a user; an indirect injection can be hidden in a web page, email, document, or tool result that the agent reads. Because the model processes instructions and data in the same language channel, telling it to ‘ignore malicious instructions’ is not a complete defense.

Reduce the blast radius with least functionality, least privilege, and least autonomy. Separate trusted instructions from untrusted content, allowlist tools and domains, validate tool arguments, keep read and write capabilities separate, require approval for side effects, sanitize outputs before downstream execution, set limits, and monitor unusual sequences. Guardrails complement—not replace—authorization controls.

04 · People and accountability

Responsible integration changes roles, training, and escalation paths

AI can augment work only when people know what the system does, where it fails, and who owns the final decision.

Assign an accountable business owner, system owner, data owner, security and privacy reviewers, and frontline users. Document which decisions remain human, how users challenge an output, how incidents are reported, and how the system is disabled. Train people on realistic failures rather than generic warnings.

Workforce adaptation is not only a technical rollout. Redesign the workflow, define new review responsibilities, measure whether the system actually improves service, and watch for automation bias, deskilling, hidden work, and unequal burden. Communicate what changes and what does not.

01 · Evaluation before launch

Define good behavior with examples and graders

Evaluation begins by collecting representative tasks and writing observable success criteria.

Build a dataset from ordinary cases, difficult boundaries, known failures, missing-information cases, adversarial inputs, and important user groups. Keep an untouched set for final comparison. Graders can include exact checks, schema validation, retrieval relevance, citation support, tool-choice correctness, human rubrics, and model-based judging calibrated against humans.

Measure components and the entire workflow. A RAG assistant needs retrieval recall and answer faithfulness; an agent needs correct tool choice, argument accuracy, handoff behavior, approval compliance, and final task success. Trace evaluation examines the sequence of model calls, tools, guardrails, and handoffs so a passing final answer does not hide unsafe behavior.

03 · Monitoring after launch

Monitor inputs, traces, outputs, outcomes, and resource use

Production quality can drift even when the model version does not change.

Track input mix, retrieval failures, citation coverage, abstention, schema errors, tool-call success, approval rates, guardrail events, escalation, latency, tokens, and cost. Sample outputs for human review and segment metrics by important user or task groups. Preserve enough trace data to diagnose failures while respecting privacy and retention limits.

Connect system metrics to business outcomes such as resolution time, first-contact resolution, user correction rate, avoided manual steps, error severity, and user trust. A lower cost per call is not a success if escalation or rework rises. Define alerts, owners, severity levels, and rollback or shutdown procedures.

04 · Rollout and improvement

Adoption is a controlled change to a workflow

Start narrow, expose errors safely, and expand authority only after evidence.

A staged rollout can move from offline testing to shadow mode, internal pilot, limited user group, broader availability, and carefully approved actions. Shadow mode lets the system make recommendations without affecting production decisions. Compare with the current process and collect structured user corrections rather than only satisfaction scores.

Every incident, escalation, and correction can feed an improvement loop: classify the failure, add a representative case to the evaluation set, change one component, rerun comparisons, document the result, and deploy with rollback. Training and communication should explain the new division of work, review responsibility, and fallback—not simply teach interface clicks.