Explain what an SVM is, what it's mainly used for, and what kind of boundary it looks for.

• What it is — a powerful supervised learning algorithm.
• Main use — mainly classification; a regression version (SVR) also exists.
• What it finds — the best possible boundary, a hyperplane, that separates two classes.
• "Best" — the boundary with the maximum possible margin between the classes.
• Where it shines — high-dimensional spaces, and data with a clear gap between classes.

Describe what the margin is and why SVM picks the boundary with the largest one.

• Many possible lines — lots of lines could separate two classes.
• SVM's choice — the one with the largest margin.
• Margin defined — the distance between the boundary and the closest data points from each class.
• Why wider is better — a wider margin generally means better generalization to new, unseen data.

Identify the support vectors and explain why only they matter for the boundary.

• Support vectors — the data points closest to the decision boundary.
• They set the boundary — they directly determine its position and orientation.
• Everyone else — every other point could be removed without changing the boundary at all.
• Efficiency — this makes SVM efficient at prediction time: only the support vectors matter.

Explain the difference between the two and which one is used in practice.

• Hard margin — requires perfect separation; no points allowed inside the margin.
• Hard margin's limit — only works on perfectly separable data.
• Soft margin — allows some points to be misclassified or inside the margin, to handle real, noisy data.
• In practice — real-world data is rarely perfectly separable, so soft margin is used almost always.

Describe what a large C and a small C do to the margin and to mistakes.

• C controls the soft margin — it sets how much misclassification is tolerated.
• Large C — punishes misclassification heavily → narrower margin.
• Small C — allows more flexibility → wider margin.
• Tuning is tricky — picking a good C is listed as one of SVM's weaknesses.

Describe the problem the kernel trick solves and how it solves it.

• The problem — real data is often not linearly separable in its original form.
• The trick — map the data into a higher-dimensional space, where a linear boundary can separate it.
• Efficient — this happens mathematically, without ever directly computing the new coordinates.
• Result — SVM can draw curved, complex boundaries back in the original space.
• Example — an inner circle of one class inside an outer ring of the other can't be split by a line in 2D, but after mapping to 3D a flat plane separates them.

Match each kernel to when or how it's used.

• Linear — no transformation; used when the data is already linearly separable.
• Polynomial — creates curved boundaries using polynomial combinations of features.
• RBF (Radial Basis Function) — the most popular choice for complex, nonlinear boundaries.
• Sigmoid — behaves similarly to a neural network activation function.
• Class notebook — uses kernel = 'linear'.

Explain each symbol in the decision boundary and how a point gets its class.

• Decision boundary — w · x + b = 0.
• w — the weight vector, perpendicular to the boundary.
• x — the input features; b — the bias.
• Classification rule — y = sign(w · x + b).
• Meaning — which side of the boundary a point falls on determines its predicted class.

Connect the margin to ||w|| and describe training as an optimization problem.

• Margin width — equals 2 / ||w||.
• So — maximizing the margin means minimizing ||w||.
• Training — solving an optimization problem to find the best w and b.

Name each strength and say briefly why it helps.

• High dimensions — effective in high-dimensional spaces.
• Memory-efficient — only uses the support vectors.
• Versatile — thanks to the different kernel choices.
• Clear gaps — works well when there's a clear margin of separation.

Name each weakness and connect at least one to the soft margin or kernels.

• Slow training — slow to train on very large datasets.
• Noise and overlap — performance drops with lots of noise or overlapping classes.
• Tuning — choosing the right kernel and tuning C can be tricky.
• No probabilities — doesn't directly output probabilities.

Name four use cases and summarize the lecture's three takeaways.

• Text — text classification and spam filtering.
• Images — image classification and face detection.
• Bioinformatics — e.g., gene and protein classification.
• Handwriting — handwriting recognition.
• Takeaways — finds the maximum-margin boundary · support vectors are the few points that define it · soft margins and kernels make it flexible for real, messy, non-linear data.

Explain how the notebook builds X and y and splits them 75/25.

• Load — pd.read_csv('Social_Network_Ads.csv'): 400 rows, columns Age, EstimatedSalary, Purchased.
• Features X (uppercase) — dataset.iloc[:, :-1].values: every column but the last (Age, EstimatedSalary).
• Target y (lowercase) — dataset.iloc[:, -1].values: the last column, Purchased (0 or 1).
• Split — train_test_split(X, y, test_size = 0.25, random_state = 0) → 300 training rows, 100 test rows.
• random_state = 0 — makes the split the same every run, so results are repeatable.

Walk through the StandardScaler cell and why it's fit on the training set only.

• Create — sc = StandardScaler().
• Fit on train only — X_train = sc.fit_transform(X_train) learns each feature's mean and standard deviation from the training data.
• Reuse on test — X_test = sc.transform(X_test) applies those same numbers; it never learns from the test set.
• Why — age (about 18–60) and salary (about 15,000–150,000) are on very different scales; without scaling, salary would swamp age.
• SVM link (study aid) — the margin is a distance, so big-number features would dominate it.

Explain SVC(kernel = 'linear', random_state = 0), its printed defaults, and what .fit does.

• Import — from sklearn.svm import SVC (SVC = the scikit-learn class for SVM classification).
• Create — classifier = SVC(kernel = 'linear', random_state = 0): a straight-line (linear) boundary.
• Printed defaults — C=1.0 (the soft-margin penalty) and probability=False (no probabilities, matching the lecture's weakness).
• Train — classifier.fit(X_train, y_train) solves the optimization for the best w and b.
• Unlike K-NN — SVM really learns a boundary at training time; it doesn't just store the data.

Explain classifier.predict(sc.transform([[30, 87000]])) inside-out and its output.

• Inside first — [[30, 87000]] is one person (age 30, salary $87,000) as a 2-D list: one row, two features.
• Scale it — sc.transform(...) uses the training mean and standard deviation.
• Predict — classifier.predict(...) checks which side of the boundary the point falls on.
• Output — [0]: predicted not to purchase.
• Why scale — the model was trained on scaled numbers, so new inputs must be scaled the same way.

Label each number in [[66 2] [8 24]] and compute the accuracy of 0.9.

• Predictions — y_pred = classifier.predict(X_test), printed side by side with y_test.
• Layout — confusion_matrix(y_test, y_pred): rows = actual, columns = predicted, class 0 first → [[TN FP] [FN TP]].
• The numbers — TN = 66, FP = 2, FN = 8, TP = 24.
• Accuracy — (TP + TN) / total = (24 + 66) / 100 = 0.9.
• Mistakes — 2 + 8 = 10 of 100; most mistakes are missed buyers (FN = 8).

Describe how the plotting cell builds the chart and what the boundary looks like.

• Real units — sc.inverse_transform(...) puts real ages and salaries back on the axes.
• Grid — np.meshgrid(..., step = 0.25) builds a very fine grid of (age, salary) points around the data.
• Background — plt.contourf predicts every grid point and paints it: red = 0, green = 1.
• Dots — plt.scatter draws each real person in their true color.
• Boundary — a straight line running from young, high earners down to older, low earners, because the kernel is linear.
• Mistakes — dots on the wrong color; many missed buyers are older people with lower salaries, below the line.

Use the Module 6, 7 and 8 notebooks (same data, split and scaling) to compare the three models.

• Same pipeline — same CSV, split, scaling, evaluation and plots; only the classifier lines change.
• How each learns — logistic regression learns weights and a bias · K-NN just stores the data · SVM learns the maximum-margin w and b.
• Boundaries — logistic regression and linear SVM: straight lines · K-NN: irregular and jagged.
• Accuracy — logistic regression 0.89 · linear SVM 0.90 · K-NN 0.93.
• Why — the purchase pattern isn't a straight line, so the two straight-line models both miss 8 buyers; K-NN misses only 3.