Explain what logistic regression is, what kind of problem it solves, and what its raw output is.

• What it is — a statistical / machine learning algorithm that predicts the probability of a categorical outcome.
• Classification, not regression — despite the name, it is used for classification tasks.
• Output — a probability between 0 and 1, which is then mapped to a class label.
• Goal — estimate the probability of an outcome, then make a decision from it.
• Reputation — one of the most widely used, fast, and interpretable models in industry.

Contrast logistic regression with linear regression and state the rule for choosing between them.

• Why the name confuses — it's built on regression math, but it solves classification problems.
• Linear regression — predicts a continuous number: a price, a temperature, a score.
• Logistic regression — predicts a category (yes/no, spam/not spam) by predicting the probability of belonging to a class.
• Rule of thumb — use logistic regression when the target is categorical, not continuous.

Recognize the problems logistic regression is built for and explain why it works for them.

• Best fit — binary classification: problems with exactly two possible outcomes.
• Email & medical — spam or not spam · disease present or not present.
• Finance & marketing — loan approved or denied · customer will churn or stay.
• Beyond two classes — it can also be extended to multi-class problems.
• Why it works — it models the relationship between the features and the probability of an outcome with an S-shaped (sigmoid) curve.

Give the problems with fitting a straight line to class labels and what logistic regression does instead.

• Unbounded output — linear regression can output anything from −∞ to +∞, which is not a valid probability.
• Impossible values — its straight line can predict values below 0 or above 1.
• Poor separation — a straight line doesn't naturally separate two classes well, especially with outliers, which it can misclassify.
• The fix — we need an output squeezed between 0 and 1. Logistic regression's sigmoid approaches 0 and 1 but never crosses them.

Write the sigmoid, explain what it does, and give its value at the three landmark inputs.

• Formula — σ(z) = 1 / (1 + e^−z).
• What it does — takes any real number z and squashes it into a range between 0 and 1.
• Read as probability — the output is interpreted directly as a probability.
• Landmarks — large positive z → near 1 (z = 6 → ≈ 1) · large negative z → near 0 (z = −6 → ≈ 0) · z = 0 → exactly 0.5.
• Shape — an S-curve; in the steep middle, a small change in input causes a large change in probability.

Show how a row of feature values becomes a probability, and name what the model learns.

• Step 1 · linear part — z = w₁x₁ + w₂x₂ + … + w_nx_n + b: a weighted sum of the inputs, exactly like linear regression.
• Step 2 · squash — p = σ(z) = 1 / (1 + e^−z) turns z into a probability.
• What's learned — the best weights (w) and bias (b), found during training.
• The foundation — linear combination, then sigmoid: this two-step process is the whole basis of logistic regression.

Turn a probability into a class, and explain when to move the threshold.

• Probability first — the model outputs a probability, for example p = 0.82.
• Threshold — the probability becomes a class using a threshold, commonly 0.5.
• Decision rule — p ≥ 0.5 → Class 1 · p < 0.5 → Class 0. At exactly 0.5 the model is equally unsure; that's the decision boundary.
• Adjustable — the threshold can move depending on whether false positives or false negatives matter more.
• Trade-off — lower threshold: fewer false negatives, more false positives · higher threshold: fewer false positives, more false negatives.

Write the cost function, explain what it rewards and punishes, and how the model minimizes it.

• Formula — Cost = −[ y·log(p) + (1 − y)·log(1 − p) ], where y = the true label (0 or 1) and p = the predicted probability.
• Name — binary cross-entropy, also called log loss: logistic regression's cost function.
• What it measures — how wrong a single prediction is; during training it's averaged across all data points.
• Penalty shape — heavily penalizes confident, wrong predictions, much more than a small, cautious miss.
• Training — the model adjusts its weights with gradient descent to minimize this cost over many training iterations.

Classify a problem as one of the three types of logistic regression.

• Binary — exactly two classes; the most common case (spam vs. not spam, 0 vs. 1).
• Multinomial — three or more classes with no natural order (cat vs. dog vs. bird).
• Ordinal — three or more classes with a natural order (low vs. medium vs. high risk).
• Telling them apart — count the classes first (two → binary); with three or more, ask whether they have a ranking (yes → ordinal, no → multinomial).

Match logistic regression to its real-world uses and summarize how it works end to end.

• Detect & diagnose — spam detection (spam or not) · medical diagnosis (disease present or absent).
• Decide & predict behavior — credit scoring (approve or deny a loan) · customer churn (stay or leave) · ad targeting (click or not).
• Core pipeline — linear combination → sigmoid → probability → threshold → class.
• Trained by — minimizing log loss with gradient descent.
• Its role — a simple, fast, highly interpretable baseline model for binary classification.

Explain the import and data-loading cells of the class notebook.

• Libraries — import numpy as np · import matplotlib.pyplot as plt · import pandas as pd.
• Load — dataset = pd.read_csv('Social_Network_Ads.csv'): 400 rows; columns Age, EstimatedSalary, Purchased.
• Features — X = dataset.iloc[:, :-1].values: all rows, every column except the last (Age, EstimatedSalary). Uppercase X = 2-D matrix.
• Target — y = dataset.iloc[:, -1].values: all rows, last column only (Purchased). Lowercase y = 1-D vector.
• Why logistic — Purchased has exactly two values (0 and 1), so it's a binary classification problem.

Explain the train/test split and feature-scaling cells, including why scaling is fit on training data only.

• Split — train_test_split(X, y, test_size = 0.25, random_state = 0) → 300 training rows, 100 test rows.
• Output order — X_train, X_test, y_train, y_test.
• random_state = 0 — fixes the shuffle so the same rows land in the test set on every run.
• Scale — sc = StandardScaler() · X_train = sc.fit_transform(X_train) · X_test = sc.transform(X_test).
• Fit on train only — the scaler learns its mean and standard deviation from the training rows and reuses them on the test rows, so no test information leaks in. Example: first training row [44, 39000] → [0.58, −0.89].

Explain how the model object is created and trained, and connect fit() to the theory.

• Import — from sklearn.linear_model import LogisticRegression.
• Create — classifier = LogisticRegression(random_state = 0) builds an untrained model object.
• Train — classifier.fit(X_train, y_train) learns from the scaled training features and their labels.
• Training data only — fit never sees X_test or y_test; those are saved for checking the model.
• Link to theory — fit is where the model learns the best weights and bias by minimizing log loss.

Explain the two prediction cells and how to read their output.

• One new person — classifier.predict(sc.transform([[30, 87000]])) → [0]: a 30-year-old earning 87,000 is predicted not to purchase.
• Scale new input first — use the same sc.transform, because the model was trained on scaled numbers.
• Double brackets — [[30, 87000]] is one row with two feature values, shaped like X.
• Whole test set — y_pred = classifier.predict(X_test) returns a 0/1 prediction for all 100 test rows.
• Side by side — np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)),1) prints predicted (left) next to actual (right).

Explain the evaluation cell and read the class result correctly.

• Code — from sklearn.metrics import confusion_matrix, accuracy_score · cm = confusion_matrix(y_test, y_pred).
• Class result — [[65 3] [8 24]].
• scikit-learn layout — rows = actual, columns = predicted, class 0 first: [[TN FP] [FN TP]] → TN 65 · FP 3 · FN 8 · TP 24.
• Accuracy — accuracy_score(y_test, y_pred) = 0.89 = (65 + 24) / 100.
• Watch the order — Module 5's matrix puts the positive class first (TP top-left); scikit-learn prints class 0 first, so TP is bottom-right.

Explain what the visualization cell builds and how to read the chart.

• Back to real units — X_set = sc.inverse_transform(X_train) so the axes show real ages and salaries.
• Grid — np.meshgrid builds a dense grid of points covering the chart (age ±10, salary ±1000 past the data, step 0.25).
• Color the regions — each grid point is scaled and predicted; plt.contourf paints class 0 red and class 1 green.
• Dots — plt.scatter plots the real training points in their true colors (red = 0, green = 1).
• Reading it — the straight edge between red and green is the decision boundary (p = 0.5); older, higher-salary people fall in the green region; dots on the wrong color are misclassified.