Machine Learning Programming Practice Exam

Question 1 Machine Learning Programming

What is an outlier in machine learning?

An outlier is a data point that significantly deviates from the rest of the distribution. Outliers can be data errors (should be removed/corrected) or genuine rare events (worth keeping or modeling). Robust algorithms (e.g., RANSAC, Huber loss, isolation forest) are less sensitive to outliers. DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering algorithm that groups together points that are density-connected and marks points in low-density regions as outliers. Unlike k-means, it does not require specifying the number of clusters and can find arbitrarily shaped clusters. Cross-validation is a technique for evaluating model performance by splitting data into multiple folds, training on some folds and testing on the remaining fold, then rotating. K-fold cross-validation is the most common variant. In scikit-learn: cross_val_score(model, X, y, cv=5). It provides a more robust estimate than a single train/test split. Unsupervised learning is a type of machine learning where the model is trained on unlabeled data and must discover hidden patterns or structures on its own. Common tasks include clustering (grouping similar data points), dimensionality reduction, and anomaly detection. Examples include k-means clustering and PCA.

Question 2 Machine Learning Programming

What is UMAP?

Regularization is a technique that adds a penalty term to the loss function to discourage overly complex models and prevent overfitting. L1 (Lasso) adds the sum of absolute weights and can produce sparse models. L2 (Ridge) adds the sum of squared weights and shrinks coefficients. Elastic Net combines both. VAEs maximize a variational lower bound; produce blurry but diverse samples; fast sampling. GANs use adversarial training; produce sharp samples but can be unstable and mode-collapse prone. Diffusion models iteratively denoise; produce high-quality, diverse samples but require many sampling steps. Diffusion currently leads in image synthesis. A validation set is a portion of the data used to tune hyperparameters and evaluate model performance during training, separate from both training and test sets. It helps in model selection and preventing overfitting to the test set. A typical split is 60% train, 20% validation, 20% test. Cross-validation can replace a fixed validation set. UMAP (Uniform Manifold Approximation and Projection) is a dimensionality reduction technique based on Riemannian geometry and topological data analysis. It is often faster and more global-structure-preserving than t-SNE and supports supervised and metric learning extensions. Outputs can also be used as features.

Question 3 Machine Learning Programming

What is a convolutional layer?

A random forest is an ensemble learning method that constructs multiple decision trees during training and outputs the mode (classification) or mean (regression) of the individual trees' predictions. It reduces overfitting by using bagging (bootstrap aggregating) and random feature selection. In scikit-learn: RandomForestClassifier(). Data leakage occurs when information from outside the training set leaks into the model, giving unrealistically good training/validation scores but poor real-world performance. Common causes include fitting preprocessing (scaling, imputation) on the full dataset before splitting, target leakage from future data, or duplicate rows across splits. Contrastive learning trains representations by pulling similar pairs together and pushing dissimilar pairs apart in embedding space. Losses include InfoNCE, triplet loss, and SupCon. It is the foundation of modern self-supervised methods (SimCLR, MoCo, CLIP) and metric-learning systems like face recognition. A convolutional layer applies learnable filters (kernels) that slide across the input, computing dot products to produce feature maps. Kernels share weights across spatial positions, drastically reducing parameters versus dense layers and exploiting translation equivariance. Common kernel sizes are 3×3 and 5×5.

Question 4 Machine Learning Programming

What is a self-supervised learning?

Sentiment analysis classifies the polarity of text (positive, negative, neutral), sometimes also emotions or aspect-level opinions. Approaches range from lexicon-based (VADER, AFINN) to classical ML (TF-IDF + logistic regression) to fine-tuned transformers. It is widely used for brand monitoring, reviews, and social media analysis. Self-supervised learning is a paradigm where the model generates its own supervision signal from the input data, typically by predicting masked, missing, or transformed parts of the input. Examples include BERT (masked language modeling) and SimCLR (contrastive image representations). It bridges supervised and unsupervised learning and powers modern foundation models. BLEU (Bilingual Evaluation Understudy) measures the similarity between machine-generated and reference text by counting overlapping n-grams (typically 1–4) with a brevity penalty. It ranges 0–1 (or 0–100). It is the standard metric for machine translation, though it has known weaknesses for paraphrases. A random forest is an ensemble learning method that constructs multiple decision trees during training and outputs the mode (classification) or mean (regression) of the individual trees' predictions. It reduces overfitting by using bagging (bootstrap aggregating) and random feature selection. In scikit-learn: RandomForestClassifier().

Question 5 Machine Learning Programming

What is AUC (Area Under the Curve)?

Autocorrelation measures the correlation between a time series and a lagged version of itself. The ACF plot shows correlations for various lags, helping identify seasonality, trend, and suitable lag features. PACF (partial ACF) helps determine ARIMA orders. Train/test split is the practice of dividing a dataset into separate subsets for training and evaluation. A common split is 80/20 or 70/30. The model learns from the training set and is evaluated on the unseen test set to estimate generalization. In scikit-learn: train_test_split(X, y, test_size=0.2, random_state=42). Contrastive learning trains representations by pulling similar pairs together and pushing dissimilar pairs apart in embedding space. Losses include InfoNCE, triplet loss, and SupCon. It is the foundation of modern self-supervised methods (SimCLR, MoCo, CLIP) and metric-learning systems like face recognition. AUC measures the entire area under the ROC curve and provides an aggregate measure of classifier performance across all thresholds. An AUC of 1.0 indicates a perfect model, while 0.5 indicates a random classifier. AUC is threshold-independent and useful for comparing models. In scikit-learn: roc_auc_score(y_true, y_scores).

Question 6 Machine Learning Programming

What is the learning rate schedule?

A feature store is a centralized repository that stores, manages, and serves features for ML training and inference, ensuring consistency between offline and online environments. Examples include Feast, Tecton, and Hopsworks. It solves the "training-serving skew" problem by maintaining a single source of truth for features. ROUGE (Recall-Oriented Understudy for Gisting Evaluation) is a family of metrics for evaluating summarization and other text generation tasks. ROUGE-N measures n-gram recall; ROUGE-L uses longest common subsequence. Higher scores indicate greater overlap with reference summaries. Dropout is a regularization technique that randomly sets a fraction of neuron outputs to zero during training, preventing the network from relying too heavily on specific neurons. A typical dropout rate is 0.2 to 0.5. This forces the network to learn more robust features. Dropout is disabled during inference (prediction). A learning rate schedule adjusts the learning rate during training according to a predefined rule. Common strategies include step decay, exponential decay, cosine annealing, and warm restarts. Scheduling often yields faster convergence and better final performance than a fixed learning rate.

Question 7 Machine Learning Programming

What is recall (sensitivity) in classification?

A GMM assumes data is generated from a mixture of a finite number of Gaussian distributions with unknown parameters. It is fit via the Expectation-Maximization (EM) algorithm. GMMs generalize k-means by allowing soft, probabilistic cluster assignments and elliptical cluster shapes. Recall measures the proportion of actual positives that are correctly identified: recall = TP / (TP + FN). High recall means the model has a low false negative rate. Recall is critical when missing a positive case is costly, such as detecting cancer or fraud. The bias-variance tradeoff describes the tension between two sources of error:

Bias: error from overly simple assumptions (underfitting)
Variance: error from sensitivity to small fluctuations in training data (overfitting)

The goal is to find a model complexity that minimizes total error, which is the sum of bias², variance, and irreducible error. ANN search trades exactness for massive speedups in finding nearest neighbors in high-dimensional spaces. Algorithms include HNSW, IVF, and LSH. Vector databases implement ANN to support billion-scale retrieval in milliseconds, at the cost of slightly reduced recall.

Question 8 Machine Learning Programming

What is Cohen's Kappa?

The learning rate is a hyperparameter that controls the step size during weight updates in gradient descent. A learning rate that is too large can cause the algorithm to overshoot the minimum, while one that is too small leads to slow convergence. Common practice is to start with values like 0.01 or 0.001 and use learning rate schedules. Transfer learning is the practice of reusing a model pre-trained on one task as the starting point for a related task. It is especially powerful in deep learning where large pre-trained models (e.g., ResNet, BERT) are fine-tuned on smaller domain-specific datasets. It drastically reduces training time and data requirements. Cohen's Kappa is a classification metric that adjusts accuracy for agreement that could occur by chance: κ = (p_o − p_e) / (1 − p_e). Values above 0.8 indicate strong agreement. It is especially useful for imbalanced classes where raw accuracy can be misleading. Pruning removes unimportant weights, neurons, or layers from a trained network to reduce size and compute. Magnitude pruning zeros small weights; structured pruning removes whole filters/channels. Combined with fine-tuning, pruning can shrink models by 50–90% with little accuracy loss.

Question 9 Machine Learning Programming

What is train/test split?

Cohen's Kappa is a classification metric that adjusts accuracy for agreement that could occur by chance: κ = (p_o − p_e) / (1 − p_e). Values above 0.8 indicate strong agreement. It is especially useful for imbalanced classes where raw accuracy can be misleading. Naive Bayes is a probabilistic classifier based on Bayes' theorem with a (naive) assumption of feature independence. Despite the strong assumption, it works surprisingly well for text classification and spam filtering. Variants include Multinomial, Bernoulli, and Gaussian Naive Bayes. Prophet is an open-source forecasting library from Meta designed for business time series with daily seasonality, holidays, and trend changes. It decomposes series into trend, seasonality, and holiday components and fits quickly via Bayesian-style optimization. It is robust to missing data and outliers and is accessible to non-experts. Train/test split is the practice of dividing a dataset into separate subsets for training and evaluation. A common split is 80/20 or 70/30. The model learns from the training set and is evaluated on the unseen test set to estimate generalization. In scikit-learn: train_test_split(X, y, test_size=0.2, random_state=42).

Question 10 Machine Learning Programming

What is DBSCAN?

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering algorithm that groups together points that are density-connected and marks points in low-density regions as outliers. Unlike k-means, it does not require specifying the number of clusters and can find arbitrarily shaped clusters. Unsupervised learning is a type of machine learning where the model is trained on unlabeled data and must discover hidden patterns or structures on its own. Common tasks include clustering (grouping similar data points), dimensionality reduction, and anomaly detection. Examples include k-means clustering and PCA. Naive Bayes is a probabilistic classifier based on Bayes' theorem with a (naive) assumption of feature independence. Despite the strong assumption, it works surprisingly well for text classification and spam filtering. Variants include Multinomial, Bernoulli, and Gaussian Naive Bayes. A perceptron is the simplest artificial neuron, computing a weighted sum of inputs, adding a bias, and applying a step function as activation. It can only solve linearly separable problems (e.g., AND, OR) but cannot learn XOR. Stacking perceptrons in layers produces a multilayer perceptron (MLP).

Question 11 Machine Learning Programming

What is a fully connected layer?

Cosine similarity measures the angle between two vectors, ignoring magnitude: cos(A,B) = (A·B) / (‖A‖·‖B‖). It ranges from -1 to 1. It is widely used for comparing text embeddings and recommender systems because it focuses on directional similarity rather than absolute values. One-hot encoding is a technique for converting categorical variables into binary vectors. Each category becomes a new binary feature column with a 1 indicating the presence of that category and 0 otherwise. For example, colors [red, blue, green] become three columns. In scikit-learn: OneHotEncoder() or in pandas: pd.get_dummies(). GPT (Generative Pre-trained Transformer) is a decoder-only transformer model pre-trained with autoregressive language modeling (predicting the next token). Successive versions (GPT-2, GPT-3, GPT-4) scaled to hundreds of billions of parameters. GPT models are the basis for ChatGPT-style generative assistants. A fully connected (dense) layer connects every input neuron to every output neuron, multiplying by a weight matrix and adding a bias. It is typically used at the end of CNNs and MLPs to combine learned features for final prediction. The parameter count is large: in_features × out_features.

Question 12 Machine Learning Programming

What is layer normalization?

Log loss (logistic loss / cross-entropy) measures the negative log-likelihood of predicted probabilities: L = −(1/n)·Σ[y·log(p) + (1−y)·log(1−p)]. It heavily penalizes confident wrong predictions and is the standard training objective for probabilistic classifiers. Lower is better; 0 is perfect. Quantization reduces the numerical precision of model weights and/or activations (e.g., from float32 to int8), shrinking model size and speeding up inference, often with minimal accuracy loss. Post-training quantization converts after training; quantization-aware training simulates low precision during training for better results. The elbow method helps determine the optimal number of clusters (k) by plotting the within-cluster sum of squares (WCSS) against different values of k. The optimal k is at the "elbow" point where adding more clusters no longer significantly reduces WCSS. It is a heuristic method and sometimes the elbow point is ambiguous. Layer normalization normalizes activations across features within a single sample (rather than across the batch as in batch norm). It is independent of batch size, making it ideal for transformers, RNNs, and small-batch or online learning. It typically improves training stability.

Question 13 Machine Learning Programming

What is the Adam optimizer?

Mask R-CNN extends Faster R-CNN by adding a parallel branch that predicts a binary mask for each detected object. It performs instance segmentation: detecting each object and producing its pixel-level mask. It is widely used in applications requiring precise object outlines (e.g., robotics, biology, AR). Adam (Adaptive Moment Estimation) is an optimization algorithm that combines momentum (first moment) with RMSProp-style adaptive learning rates (second moment). It maintains per-parameter learning rates and works well across many deep learning tasks with default hyperparameters (lr=1e-3, beta1=0.9, beta2=0.999). Supervised learning is a type of machine learning where the model is trained on labeled data, meaning each training example includes an input and its corresponding correct output. The algorithm learns a mapping from inputs to outputs, which it then uses to make predictions on unseen data. Common tasks include classification and regression. POS tagging assigns a grammatical category (noun, verb, adjective, etc.) to each token in a sentence. Modern taggers use neural sequence models, often BiLSTMs or transformers, and reach 97%+ accuracy on English. POS tags are features for parsing, NER, and many downstream NLP tasks.

Question 14 Machine Learning Programming

What is CLIP?

Activation functions introduce non-linearity into neural networks, enabling them to learn complex patterns. Common activation functions include:

ReLU: max(0, x) — most widely used in hidden layers
Sigmoid: outputs between 0 and 1 — used for binary classification output
Tanh: outputs between -1 and 1
Softmax: outputs probabilities for multi-class classification

CLIP (Contrastive Language-Image Pre-training) trains an image encoder and text encoder jointly to align images with their captions using a contrastive InfoNCE loss on a huge image-text dataset. The aligned space enables zero-shot image classification from natural-language prompts and powers text-to-image systems like DALL·E. Concept drift occurs when the relationship between features and the target changes over time (e.g., user preferences shift). It requires models to be continuously updated. Detection methods track performance metrics over time; mitigation strategies include sliding-window retraining, online learning, and ensemble weighting. Normalization (Min-Max scaling) rescales features to a range of [0, 1]: (x - min) / (max - min). Standardization (Z-score scaling) transforms features to have mean 0 and standard deviation 1: (x - mean) / std. Use normalization when bounds matter, and standardization when the data follows a Gaussian distribution.

Question 15 Machine Learning Programming

What is the BLEU score?

BLEU (Bilingual Evaluation Understudy) measures the similarity between machine-generated and reference text by counting overlapping n-grams (typically 1–4) with a brevity penalty. It ranges 0–1 (or 0–100). It is the standard metric for machine translation, though it has known weaknesses for paraphrases. A convolutional layer applies learnable filters (kernels) that slide across the input, computing dot products to produce feature maps. Kernels share weights across spatial positions, drastically reducing parameters versus dense layers and exploiting translation equivariance. Common kernel sizes are 3×3 and 5×5. An outlier is a data point that significantly deviates from the rest of the distribution. Outliers can be data errors (should be removed/corrected) or genuine rare events (worth keeping or modeling). Robust algorithms (e.g., RANSAC, Huber loss, isolation forest) are less sensitive to outliers. Recall measures the proportion of actual positives that are correctly identified: recall = TP / (TP + FN). High recall means the model has a low false negative rate. Recall is critical when missing a positive case is costly, such as detecting cancer or fraud.

Question 16 Machine Learning Programming

What is a VAE (Variational Autoencoder)?

Pruning removes unimportant weights, neurons, or layers from a trained network to reduce size and compute. Magnitude pruning zeros small weights; structured pruning removes whole filters/channels. Combined with fine-tuning, pruning can shrink models by 50–90% with little accuracy loss. A VAE is a generative model that learns a probabilistic latent space. The encoder maps input to a distribution (mean and variance), and the decoder reconstructs input from sampled latent codes. Trained by maximizing the ELBO (evidence lower bound). VAEs produce blurry but diverse samples and enable smooth latent-space interpolation. Autocorrelation measures the correlation between a time series and a lagged version of itself. The ACF plot shows correlations for various lags, helping identify seasonality, trend, and suitable lag features. PACF (partial ACF) helps determine ARIMA orders. The learning rate is a hyperparameter that controls the step size during weight updates in gradient descent. A learning rate that is too large can cause the algorithm to overshoot the minimum, while one that is too small leads to slow convergence. Common practice is to start with values like 0.01 or 0.001 and use learning rate schedules.

Question 17 Machine Learning Programming

What is a recurrent neural network (RNN)?

An RNN is a neural network designed for sequential data where connections form directed cycles, allowing information to persist across timesteps. Hidden states act as memory. RNNs are used for time series, speech, and text, but suffer from vanishing/exploding gradients, motivating LSTM and GRU variants. UMAP (Uniform Manifold Approximation and Projection) is a dimensionality reduction technique based on Riemannian geometry and topological data analysis. It is often faster and more global-structure-preserving than t-SNE and supports supervised and metric learning extensions. Outputs can also be used as features. ReLU is the most widely used activation function in neural networks, defined as f(x) = max(0, x). It outputs the input directly if positive, otherwise outputs zero. ReLU helps mitigate the vanishing gradient problem and enables faster training. A variant, Leaky ReLU, allows a small gradient for negative inputs: f(x) = max(0.01x, x). Fine-tuning updates model weights to bake knowledge or style into the model — expensive and static. RAG (Retrieval-Augmented Generation) keeps the model fixed and instead retrieves relevant documents at inference, feeding them into the prompt. RAG is cheap, up-to-date, and reduces hallucination.

Question 18 Machine Learning Programming

What is one-class SVM?

One-class SVM is an anomaly detection method that learns a boundary around normal data in feature space using a kernel (usually RBF). Points outside the boundary are flagged as anomalies. It is useful when only "normal" examples are available for training and is implemented as OneClassSVM in scikit-learn. An ensemble method combines multiple models to produce a stronger overall prediction than any individual model. Key approaches include:

Bagging: trains models on random subsets (e.g., Random Forest)
Boosting: trains models sequentially, focusing on errors (e.g., XGBoost, AdaBoost)
Stacking: uses a meta-model to combine base model outputs

Stemming crudely chops word endings to a rough root (e.g., "running" → "run", "flies" → "fli"). Lemmatization uses vocabulary and morphological analysis to return a proper dictionary form ("flies" → "fly"). Lemmatization is more accurate but slower; stemming is faster but may produce non-words. Underfitting occurs when a model is too simple to capture the underlying patterns in the data, resulting in poor performance on both training and test data. This often happens when using an overly simple model or insufficient features. Remedies include using a more complex model, adding features, or reducing regularization.

Question 19 Machine Learning Programming

What is backpropagation?

A generative pre-trained model is first self-supervised on massive data (often predicting the next token or masked tokens) and then fine-tuned or prompted for downstream tasks. Examples include the GPT family and T5. They form the basis of foundation models that transfer broadly. A convolutional layer applies learnable filters (kernels) that slide across the input, computing dot products to produce feature maps. Kernels share weights across spatial positions, drastically reducing parameters versus dense layers and exploiting translation equivariance. Common kernel sizes are 3×3 and 5×5. Backpropagation is the algorithm used to train neural networks by computing the gradient of the loss function with respect to each weight using the chain rule of calculus. Gradients are propagated backward from the output layer to the input layer, and weights are then updated using gradient descent. It is the foundation of deep learning training. Hyperparameter tuning is the process of finding the optimal configuration settings that are set before training begins (not learned from data). Common methods include:

Grid Search: exhaustive search over specified values
Random Search: random sampling of parameter space
Bayesian Optimization: informed search using past results

In scikit-learn: GridSearchCV() and RandomizedSearchCV().

Question 20 Machine Learning Programming

What is hyperparameter tuning?

Hyperparameter tuning is the process of finding the optimal configuration settings that are set before training begins (not learned from data). Common methods include:

Grid Search: exhaustive search over specified values
Random Search: random sampling of parameter space
Bayesian Optimization: informed search using past results

In scikit-learn: GridSearchCV() and RandomizedSearchCV(). A loss function (or cost function) measures how far the model's predictions are from the actual values. The model is trained to minimize this function. Common loss functions include:

MSE (Mean Squared Error) for regression
Cross-Entropy for classification
Hinge Loss for SVMs

The choice of loss function depends on the task. The bias-variance tradeoff describes the tension between two sources of error:

Bias: error from overly simple assumptions (underfitting)
Variance: error from sensitivity to small fluctuations in training data (overfitting)

The goal is to find a model complexity that minimizes total error, which is the sum of bias², variance, and irreducible error. The receptive field is the region of the input that influences a particular neuron. In CNNs, deeper neurons have larger receptive fields, allowing them to capture more global patterns. Dilated convolutions and pooling can rapidly enlarge the receptive field without adding parameters.

Question 21 Machine Learning Programming

What is model quantization?

t-SNE (t-Distributed Stochastic Neighbor Embedding) is a nonlinear dimensionality reduction technique primarily used for visualizing high-dimensional data in 2D or 3D. It preserves local neighborhoods by matching probability distributions over pairwise similarities. Use perplexity (typically 5–50) carefully; t-SNE is for visualization, not feature extraction. Embedding fine-tuning adjusts pre-trained embeddings (e.g., BERT, sentence-transformers) on a domain-specific dataset so they better reflect task-relevant similarity. Contrastive losses like InfoNCE are commonly used. It is essential for domain-specific RAG and semantic search where off-the-shelf embeddings miss nuance. Quantization reduces the numerical precision of model weights and/or activations (e.g., from float32 to int8), shrinking model size and speeding up inference, often with minimal accuracy loss. Post-training quantization converts after training; quantization-aware training simulates low precision during training for better results. An encoder-decoder (seq2seq) architecture maps an input sequence to an output sequence via two components: an encoder that compresses input into a context representation and a decoder that generates output tokens conditioned on that context. Used in machine translation, summarization, and image captioning. Transformers generalize this idea.

Question 22 Machine Learning Programming

What is named entity disambiguation?

MSE is a common loss function for regression that calculates the average of the squared differences between predicted and actual values: MSE = (1/n) * Σ(y_pred - y_actual)². It penalizes larger errors more heavily due to squaring. In scikit-learn: mean_squared_error(y_true, y_pred). A related metric is RMSE (root of MSE). Entity disambiguation (entity linking) maps a mention in text to a specific entity in a knowledge base, distinguishing e.g., "Apple" (the company) from "apple" (the fruit). It requires candidate generation, embedding-based comparison, and contextual reasoning. It is key for populating knowledge graphs. DBSCAN (Density-Based Spatial Clustering of Applications with Noise) is a clustering algorithm that groups together points that are density-connected and marks points in low-density regions as outliers. Unlike k-means, it does not require specifying the number of clusters and can find arbitrarily shaped clusters. UMAP (Uniform Manifold Approximation and Projection) is a dimensionality reduction technique based on Riemannian geometry and topological data analysis. It is often faster and more global-structure-preserving than t-SNE and supports supervised and metric learning extensions. Outputs can also be used as features.

Question 23 Machine Learning Programming

What is the F1-score?

The receptive field is the region of the input that influences a particular neuron. In CNNs, deeper neurons have larger receptive fields, allowing them to capture more global patterns. Dilated convolutions and pooling can rapidly enlarge the receptive field without adding parameters. A recommendation system predicts user preferences and suggests relevant items (products, movies, songs). Approaches include collaborative filtering (using user-item interactions), content-based (using item features), and hybrid methods. Matrix factorization and deep models (two-tower, NCF) are common backbones. The F1-score is the harmonic mean of precision and recall: F1 = 2 * (precision * recall) / (precision + recall). It provides a single metric that balances both precision and recall, making it useful when you need a balance between the two and when dealing with imbalanced datasets. The F1-score ranges from 0 to 1. Sentiment analysis classifies the polarity of text (positive, negative, neutral), sometimes also emotions or aspect-level opinions. Approaches range from lexicon-based (VADER, AFINN) to classical ML (TF-IDF + logistic regression) to fine-tuned transformers. It is widely used for brand monitoring, reviews, and social media analysis.

Question 24 Machine Learning Programming

What is the difference between bag-of-words and TF-IDF?

The elbow method helps determine the optimal number of clusters (k) by plotting the within-cluster sum of squares (WCSS) against different values of k. The optimal k is at the "elbow" point where adding more clusters no longer significantly reduces WCSS. It is a heuristic method and sometimes the elbow point is ambiguous. Bag-of-words (BoW) represents a document by raw word counts, ignoring grammar and order. TF-IDF weights each term by its frequency in the document (TF) multiplied by the inverse of its frequency across documents (IDF), downweighting common words like "the". TF-IDF typically outperforms BoW for information retrieval and classical classification. Self-attention is a mechanism where each token in a sequence computes a weighted sum of all tokens (including itself), with weights derived from learnable query, key, and value projections. It allows the model to dynamically focus on relevant context. The scaled dot-product form is: Attention(Q,K,V) = softmax(QKᵀ/√d) V. Data (or covariate) drift occurs when the statistical distribution of input features changes between training and deployment, degrading model performance. Monitoring drift (e.g., via PSI or KS tests) and retraining models are standard mitigations. Drift is a major concern in production ML systems.

Question 25 Machine Learning Programming

What is the learning rate in gradient descent?

The F1-score is the harmonic mean of precision and recall: F1 = 2 * (precision * recall) / (precision + recall). It provides a single metric that balances both precision and recall, making it useful when you need a balance between the two and when dealing with imbalanced datasets. The F1-score ranges from 0 to 1. KNN is a lazy learning algorithm that classifies a data point based on the majority class of its k nearest neighbors in feature space. It requires no training phase and stores the entire dataset. Distance metrics like Euclidean or Manhattan are used. In scikit-learn: KNeighborsClassifier(n_neighbors=5). The learning rate is a hyperparameter that controls the step size during weight updates in gradient descent. A learning rate that is too large can cause the algorithm to overshoot the minimum, while one that is too small leads to slow convergence. Common practice is to start with values like 0.01 or 0.001 and use learning rate schedules. A word embedding is a dense, low-dimensional vector representation of words learned from text, where semantically similar words have similar vectors. Classic methods include Word2Vec and GloVe; modern approaches learn embeddings contextually inside transformers. Embeddings power most NLP downstream tasks.

Question 26 Machine Learning Programming

What is mutual information for feature selection?

Adam (Adaptive Moment Estimation) is an optimization algorithm that combines momentum (first moment) with RMSProp-style adaptive learning rates (second moment). It maintains per-parameter learning rates and works well across many deep learning tasks with default hyperparameters (lr=1e-3, beta1=0.9, beta2=0.999). Class imbalance occurs when one class has far more samples than others, biasing models toward the majority class. Common remedies include resampling (oversample minority via SMOTE or undersample majority), class weighting in the loss, threshold tuning, and using metrics like F1/AUC instead of accuracy. U-Net is a CNN architecture for image segmentation with a symmetric encoder–decoder shape and skip connections that pass high-resolution features from encoder to decoder. Originally designed for biomedical segmentation, it is widely used wherever dense per-pixel prediction is needed, often with very few training images. Mutual information (MI) measures the non-linear dependency between a feature and the target, capturing relationships that correlation misses. In scikit-learn, SelectKBest(mutual_info_classif, k=10) selects the top-k features by MI. It works for both classification and regression tasks.

Question 27 Machine Learning Programming

What is linear regression?

NER is the NLP task of locating and classifying named entities in text into categories like person, organization, location, date, monetary value. It is a sequence-labeling problem often solved with CRF, BiLSTM-CRF, or transformer models (e.g., BERT). NER is foundational for information extraction and knowledge graph construction. A GMM assumes data is generated from a mixture of a finite number of Gaussian distributions with unknown parameters. It is fit via the Expectation-Maximization (EM) algorithm. GMMs generalize k-means by allowing soft, probabilistic cluster assignments and elliptical cluster shapes. Linear regression is a supervised learning algorithm that models the relationship between a dependent variable and one or more independent variables by fitting a straight line (or hyperplane). The model minimizes the sum of squared residuals between predicted and actual values. In scikit-learn, it is implemented as LinearRegression(). A GAN consists of two networks trained in opposition: a generator that creates fake samples from noise and a discriminator that tries to distinguish real from fake. Through adversarial training, the generator learns to produce increasingly realistic outputs. GANs power deepfakes, image synthesis (StyleGAN), and data augmentation.

Question 28 Machine Learning Programming

What is one-hot encoding?

One-hot encoding is a technique for converting categorical variables into binary vectors. Each category becomes a new binary feature column with a 1 indicating the presence of that category and 0 otherwise. For example, colors [red, blue, green] become three columns. In scikit-learn: OneHotEncoder() or in pandas: pd.get_dummies(). ReLU is the most widely used activation function in neural networks, defined as f(x) = max(0, x). It outputs the input directly if positive, otherwise outputs zero. ReLU helps mitigate the vanishing gradient problem and enables faster training. A variant, Leaky ReLU, allows a small gradient for negative inputs: f(x) = max(0.01x, x). Scikit-learn is a popular open-source Python library for machine learning, built on NumPy, SciPy, and matplotlib. It provides simple and efficient tools for classification, regression, clustering, dimensionality reduction, and model evaluation. Models follow a consistent API: fit(), predict(), and transform(). One-class SVM is an anomaly detection method that learns a boundary around normal data in feature space using a kernel (usually RBF). Points outside the boundary are flagged as anomalies. It is useful when only "normal" examples are available for training and is implemented as OneClassSVM in scikit-learn.

Question 29 Machine Learning Programming

What is the curse of dimensionality?

In-context learning is the ability of large language models to perform new tasks from examples given in the prompt without any weight updates. Given a few demonstrations, the model infers the pattern and continues. It is an emergent property of scale and differs from traditional fine-tuning. A GAN consists of two networks trained in opposition: a generator that creates fake samples from noise and a discriminator that tries to distinguish real from fake. Through adversarial training, the generator learns to produce increasingly realistic outputs. GANs power deepfakes, image synthesis (StyleGAN), and data augmentation. Batch normalization is a technique that normalizes the inputs of each layer across a mini-batch to have roughly zero mean and unit variance, then applies learned scale and shift parameters. It stabilizes training, allows higher learning rates, and acts as a mild regularizer. Introduced by Ioffe & Szegedy in 2015. The curse of dimensionality describes problems that arise when data lives in high-dimensional spaces: distances become less meaningful, data becomes sparse, and the volume of space grows exponentially. Effects include degraded nearest-neighbor methods, overfitting, and the need for exponentially more data. Dimensionality reduction (PCA, UMAP) helps.

Question 30 Machine Learning Programming

What is a feature store?

Weight initialization sets the starting values of network parameters and significantly affects training. Poor initialization can cause vanishing/exploding gradients. Common schemes include Xavier/Glorot (for tanh/sigmoid) and He/Kaiming (for ReLU). Modern frameworks like PyTorch and TensorFlow apply appropriate defaults automatically. A feature store is a centralized repository that stores, manages, and serves features for ML training and inference, ensuring consistency between offline and online environments. Examples include Feast, Tecton, and Hopsworks. It solves the "training-serving skew" problem by maintaining a single source of truth for features. Feature scaling is the process of normalizing or standardizing input features so they are on a comparable scale. It is critical for algorithms that rely on distance calculations (KNN, SVM) or gradient-based optimization (neural networks, logistic regression). Without scaling, features with larger magnitudes can dominate the learning process. One-hot encoding is a technique for converting categorical variables into binary vectors. Each category becomes a new binary feature column with a 1 indicating the presence of that category and 0 otherwise. For example, colors [red, blue, green] become three columns. In scikit-learn: OneHotEncoder() or in pandas: pd.get_dummies().

Question 31 Machine Learning Programming

What is k-means clustering?

Concept drift occurs when the relationship between features and the target changes over time (e.g., user preferences shift). It requires models to be continuously updated. Detection methods track performance metrics over time; mitigation strategies include sliding-window retraining, online learning, and ensemble weighting. The bias-variance tradeoff describes the tension between two sources of error:

Bias: error from overly simple assumptions (underfitting)
Variance: error from sensitivity to small fluctuations in training data (overfitting)

The goal is to find a model complexity that minimizes total error, which is the sum of bias², variance, and irreducible error. K-means is an unsupervised learning algorithm that partitions data into k clusters by iteratively assigning each point to the nearest centroid and then updating centroids to the mean of assigned points. It requires the number of clusters k to be specified in advance. In scikit-learn: KMeans(n_clusters=k). The exploding gradient problem occurs when gradients grow exponentially during backpropagation, causing unstable weight updates and divergence. Common in deep RNNs. The standard fix is gradient clipping, which caps gradient norms at a threshold. Proper weight initialization and learning rate scheduling also help.

Question 32 Machine Learning Programming

What is a GRU (Gated Recurrent Unit)?

Hyperparameter tuning is the process of finding the optimal configuration settings that are set before training begins (not learned from data). Common methods include:

Grid Search: exhaustive search over specified values
Random Search: random sampling of parameter space
Bayesian Optimization: informed search using past results

In scikit-learn: GridSearchCV() and RandomizedSearchCV(). A GRU is a simplified RNN variant that combines the forget and input gates of LSTM into a single update gate, and uses a reset gate. It has fewer parameters than LSTM, trains faster, and often performs comparably. GRUs are popular for smaller datasets and sequence-to-sequence tasks. Gradient boosting is an ensemble technique that builds models sequentially, where each new model corrects errors made by the previous ones by fitting to the residual errors. Popular implementations include XGBoost, LightGBM, and CatBoost. It typically achieves high accuracy but is prone to overfitting without proper tuning. An RNN is a neural network designed for sequential data where connections form directed cycles, allowing information to persist across timesteps. Hidden states act as memory. RNNs are used for time series, speech, and text, but suffer from vanishing/exploding gradients, motivating LSTM and GRU variants.

Question 33 Machine Learning Programming

What is label smoothing?

MLflow is an open-source platform for managing the end-to-end machine learning lifecycle: experiment tracking, model packaging, model registry, and deployment. It logs parameters, metrics, and artifacts for reproducibility. It integrates with most ML frameworks and is widely used in production ML pipelines. ReLU is the most widely used activation function in neural networks, defined as f(x) = max(0, x). It outputs the input directly if positive, otherwise outputs zero. ReLU helps mitigate the vanishing gradient problem and enables faster training. A variant, Leaky ReLU, allows a small gradient for negative inputs: f(x) = max(0.01x, x). Label smoothing is a regularization technique that replaces hard one-hot labels with a smoothed distribution (e.g., 0.9 for the true class, 0.1 spread across others). It prevents the model from becoming overconfident, improves calibration, and often boosts generalization in classification and language modeling. Word2Vec is a family of shallow neural embedding models (CBOW and Skip-gram) trained on large text corpora to produce dense word embeddings. Skip-gram predicts context words from a center word and famously captures relationships like king − man + woman ≈ queen. It popularized geometric reasoning over word meanings.

Question 34 Machine Learning Programming

What is transfer learning?

Transfer learning is the practice of reusing a model pre-trained on one task as the starting point for a related task. It is especially powerful in deep learning where large pre-trained models (e.g., ResNet, BERT) are fine-tuned on smaller domain-specific datasets. It drastically reduces training time and data requirements. MSE is a common loss function for regression that calculates the average of the squared differences between predicted and actual values: MSE = (1/n) * Σ(y_pred - y_actual)². It penalizes larger errors more heavily due to squaring. In scikit-learn: mean_squared_error(y_true, y_pred). A related metric is RMSE (root of MSE). Common strategies for handling missing data include:

Removal: drop rows or columns with missing values
Imputation: fill with mean, median, mode, or use algorithms like KNN imputation
Indicator variables: add a binary column flagging missingness

In scikit-learn: SimpleImputer(strategy='mean'). The best approach depends on the amount and pattern of missingness. GPT (Generative Pre-trained Transformer) is a decoder-only transformer model pre-trained with autoregressive language modeling (predicting the next token). Successive versions (GPT-2, GPT-3, GPT-4) scaled to hundreds of billions of parameters. GPT models are the basis for ChatGPT-style generative assistants.

Question 35 Machine Learning Programming

What is YOLO?

One-hot encoding is a technique for converting categorical variables into binary vectors. Each category becomes a new binary feature column with a 1 indicating the presence of that category and 0 otherwise. For example, colors [red, blue, green] become three columns. In scikit-learn: OneHotEncoder() or in pandas: pd.get_dummies(). ReLU is the most widely used activation function in neural networks, defined as f(x) = max(0, x). It outputs the input directly if positive, otherwise outputs zero. ReLU helps mitigate the vanishing gradient problem and enables faster training. A variant, Leaky ReLU, allows a small gradient for negative inputs: f(x) = max(0.01x, x). YOLO (You Only Look Once) is a family of real-time object detection models that frame detection as a single regression problem: a CNN predicts bounding boxes and class probabilities directly from a full image in one forward pass. It is extremely fast (30–150+ FPS) and widely used in autonomous driving, robotics, and surveillance. A/B testing in ML compares two model variants by randomly assigning users to each and measuring a business or engagement metric (not just offline accuracy). It is the gold standard for validating that a new model actually improves outcomes in production. Statistical significance and proper randomization are essential.

Question 36 Machine Learning Programming

What is approximate nearest neighbor (ANN) search?

A GMM assumes data is generated from a mixture of a finite number of Gaussian distributions with unknown parameters. It is fit via the Expectation-Maximization (EM) algorithm. GMMs generalize k-means by allowing soft, probabilistic cluster assignments and elliptical cluster shapes. ANN search trades exactness for massive speedups in finding nearest neighbors in high-dimensional spaces. Algorithms include HNSW, IVF, and LSH. Vector databases implement ANN to support billion-scale retrieval in milliseconds, at the cost of slightly reduced recall. A GAN consists of two networks trained in opposition: a generator that creates fake samples from noise and a discriminator that tries to distinguish real from fake. Through adversarial training, the generator learns to produce increasingly realistic outputs. GANs power deepfakes, image synthesis (StyleGAN), and data augmentation. Quantization reduces the numerical precision of model weights and/or activations (e.g., from float32 to int8), shrinking model size and speeding up inference, often with minimal accuracy loss. Post-training quantization converts after training; quantization-aware training simulates low precision during training for better results.

Question 37 Machine Learning Programming

What is SMOTE?

Backpropagation is the algorithm used to train neural networks by computing the gradient of the loss function with respect to each weight using the chain rule of calculus. Gradients are propagated backward from the output layer to the input layer, and weights are then updated using gradient descent. It is the foundation of deep learning training. SMOTE (Synthetic Minority Over-sampling Technique) addresses class imbalance by creating synthetic minority samples along line segments joining existing minority instances and their k-nearest neighbors. It increases minority class representation without simple duplication, reducing overfitting compared to naive oversampling. BLEU measures precision — what fraction of generated n-grams appear in references — penalizing verbose outputs. ROUGE measures recall — what fraction of reference n-grams appear in the output — penalizing missing content. BLEU is standard for translation; ROUGE is standard for summarization. A word embedding is a dense, low-dimensional vector representation of words learned from text, where semantically similar words have similar vectors. Classic methods include Word2Vec and GloVe; modern approaches learn embeddings contextually inside transformers. Embeddings power most NLP downstream tasks.

Question 38 Machine Learning Programming

What is gradient boosting?

An MLP is a fully connected feedforward neural network with one or more hidden layers between the input and output layers. Each neuron applies a non-linear activation, enabling the network to learn complex non-linear mappings. MLPs are the foundation of deep learning and are trained with backpropagation. Precision measures the proportion of positive predictions that are actually correct: precision = TP / (TP + FP). High precision means the model has a low false positive rate. Precision is important when the cost of false positives is high, such as in spam detection or medical diagnoses. GloVe (Global Vectors for Word Representation) learns word embeddings by factorizing the global co-occurrence matrix of words. It combines the strengths of global matrix factorization and local context-window methods (like Word2Vec), producing embeddings that capture both semantic and syntactic analogies efficiently. Gradient boosting is an ensemble technique that builds models sequentially, where each new model corrects errors made by the previous ones by fitting to the residual errors. Popular implementations include XGBoost, LightGBM, and CatBoost. It typically achieves high accuracy but is prone to overfitting without proper tuning.

Question 39 Machine Learning Programming

What is class imbalance and how do you handle it?

Entity disambiguation (entity linking) maps a mention in text to a specific entity in a knowledge base, distinguishing e.g., "Apple" (the company) from "apple" (the fruit). It requires candidate generation, embedding-based comparison, and contextual reasoning. It is key for populating knowledge graphs. Class imbalance occurs when one class has far more samples than others, biasing models toward the majority class. Common remedies include resampling (oversample minority via SMOTE or undersample majority), class weighting in the loss, threshold tuning, and using metrics like F1/AUC instead of accuracy. A loss function (or cost function) measures how far the model's predictions are from the actual values. The model is trained to minimize this function. Common loss functions include:

MSE (Mean Squared Error) for regression
Cross-Entropy for classification
Hinge Loss for SVMs

The choice of loss function depends on the task. A Boltzmann machine is a network of symmetrically connected stochastic units that learn a probability distribution over inputs by adjusting weights via energy-based learning. The restricted Boltzmann machine (RBM) has only visible/hidden connections (no intra-layer), enabling efficient contrastive divergence training. RBMs were foundational for deep belief nets.

Question 40 Machine Learning Programming

What is a convolutional neural network (CNN)?

A CNN is a neural network specialized for data with spatial structure (images, audio spectrograms). It uses convolutional layers with shared weights/kernels, pooling layers for downsampling, and fully connected layers at the end. CNNs dramatically reduce parameters versus MLPs and are state-of-the-art for image tasks. K-means is an unsupervised learning algorithm that partitions data into k clusters by iteratively assigning each point to the nearest centroid and then updating centroids to the mean of assigned points. It requires the number of clusters k to be specified in advance. In scikit-learn: KMeans(n_clusters=k). A GAN consists of two networks trained in opposition: a generator that creates fake samples from noise and a discriminator that tries to distinguish real from fake. Through adversarial training, the generator learns to produce increasingly realistic outputs. GANs power deepfakes, image synthesis (StyleGAN), and data augmentation. Pooling downsamples feature maps to reduce spatial size, computation, and overfitting. Max pooling takes the maximum value in each window (typically 2×2, stride 2). Average pooling takes the mean. Modern architectures sometimes use strided convolutions instead of pooling.

Question 41 Machine Learning Programming

What is the purpose of the softmax function?

A generative pre-trained model is first self-supervised on massive data (often predicting the next token or masked tokens) and then fine-tuned or prompted for downstream tasks. Examples include the GPT family and T5. They form the basis of foundation models that transfer broadly. The softmax function converts a vector of raw scores (logits) into a probability distribution where all values are between 0 and 1 and sum to 1. It is used in the output layer of multi-class classification neural networks. The formula is: softmax(z_i) = e^(z_i) / Σ(e^(z_j)). The class with the highest probability is the prediction. Segmentation models classify each pixel in an image. Semantic segmentation assigns a class label to every pixel (e.g., U-Net, DeepLab). Instance segmentation additionally distinguishes individual object instances (e.g., Mask R-CNN). They are foundational for medical imaging, autonomous driving, and scene understanding. A neural network is a computational model inspired by the brain, consisting of layers of interconnected nodes (neurons). It typically has an input layer, one or more hidden layers, and an output layer. Each connection has a weight that is adjusted during training. Neural networks can learn complex non-linear relationships in data.

Question 42 Machine Learning Programming

What is the difference between data and concept drift?

AUC measures the entire area under the ROC curve and provides an aggregate measure of classifier performance across all thresholds. An AUC of 1.0 indicates a perfect model, while 0.5 indicates a random classifier. AUC is threshold-independent and useful for comparing models. In scikit-learn: roc_auc_score(y_true, y_scores). Data drift (covariate drift): input distribution P(X) changes. Concept drift: the conditional distribution P(Y|X) changes — same input, different correct answer. Both cause model degradation but require different responses; concept drift is often subtler and harder to detect without ground truth labels. A Boltzmann machine is a network of symmetrically connected stochastic units that learn a probability distribution over inputs by adjusting weights via energy-based learning. The restricted Boltzmann machine (RBM) has only visible/hidden connections (no intra-layer), enabling efficient contrastive divergence training. RBMs were foundational for deep belief nets. Reinforcement learning is a machine learning paradigm where an agent learns to make decisions by performing actions in an environment to maximize a cumulative reward signal. The agent explores actions, receives feedback (reward or penalty), and updates its policy. Examples include game-playing AI (AlphaGo) and robotics control.

Question 43 Machine Learning Programming

What is a Gaussian Mixture Model (GMM)?

Recall measures the proportion of actual positives that are correctly identified: recall = TP / (TP + FN). High recall means the model has a low false negative rate. Recall is critical when missing a positive case is costly, such as detecting cancer or fraud. Common strategies for handling missing data include:

Removal: drop rows or columns with missing values
Imputation: fill with mean, median, mode, or use algorithms like KNN imputation
Indicator variables: add a binary column flagging missingness

In scikit-learn: SimpleImputer(strategy='mean'). The best approach depends on the amount and pattern of missingness. A GMM assumes data is generated from a mixture of a finite number of Gaussian distributions with unknown parameters. It is fit via the Expectation-Maximization (EM) algorithm. GMMs generalize k-means by allowing soft, probabilistic cluster assignments and elliptical cluster shapes. Multi-head attention runs multiple self-attention operations in parallel, each with its own learned projections, then concatenates and projects the results. It allows the model to attend to information from different representation subspaces simultaneously, capturing varied relationships. Most transformers use 8–16 heads.

Question 44 Machine Learning Programming

What is word embedding?

Backpropagation is the algorithm used to train neural networks by computing the gradient of the loss function with respect to each weight using the chain rule of calculus. Gradients are propagated backward from the output layer to the input layer, and weights are then updated using gradient descent. It is the foundation of deep learning training. A word embedding is a dense, low-dimensional vector representation of words learned from text, where semantically similar words have similar vectors. Classic methods include Word2Vec and GloVe; modern approaches learn embeddings contextually inside transformers. Embeddings power most NLP downstream tasks. The sigmoid function maps any real number to a value between 0 and 1 using the formula: σ(x) = 1 / (1 + e^(-x)). It is commonly used as the activation function in the output layer for binary classification and in logistic regression. A drawback is the vanishing gradient problem for very large or small inputs. A Boltzmann machine is a network of symmetrically connected stochastic units that learn a probability distribution over inputs by adjusting weights via energy-based learning. The restricted Boltzmann machine (RBM) has only visible/hidden connections (no intra-layer), enabling efficient contrastive divergence training. RBMs were foundational for deep belief nets.

Question 45 Machine Learning Programming

What is tokenization in NLP?

Tokenization is the process of splitting raw text into smaller units called tokens (words, subwords, or characters). Modern NLP models commonly use subword tokenization schemes such as Byte-Pair Encoding (BPE), WordPiece, or SentencePiece, which balance vocabulary size with the ability to handle rare words and morphology. The vanishing gradient problem occurs when gradients become extremely small during backpropagation through deep networks, causing early layers to learn very slowly or not at all. It is common with sigmoid/tanh activations and RNNs. Solutions include ReLU, batch normalization, residual connections, and LSTM/GRU architectures. Sentiment analysis classifies the polarity of text (positive, negative, neutral), sometimes also emotions or aspect-level opinions. Approaches range from lexicon-based (VADER, AFINN) to classical ML (TF-IDF + logistic regression) to fine-tuned transformers. It is widely used for brand monitoring, reviews, and social media analysis. Autocorrelation measures the correlation between a time series and a lagged version of itself. The ACF plot shows correlations for various lags, helping identify seasonality, trend, and suitable lag features. PACF (partial ACF) helps determine ARIMA orders.

Question 46 Machine Learning Programming

What is a segmentation model?

Segmentation models classify each pixel in an image. Semantic segmentation assigns a class label to every pixel (e.g., U-Net, DeepLab). Instance segmentation additionally distinguishes individual object instances (e.g., Mask R-CNN). They are foundational for medical imaging, autonomous driving, and scene understanding. A transformer is a neural network architecture based entirely on self-attention mechanisms, dispensing with recurrence and convolution. It processes all tokens in parallel and captures long-range dependencies efficiently. Transformers power BERT, GPT, T5, and most modern NLP/vision models. They scale well with data and compute. Common strategies for handling missing data include:

Removal: drop rows or columns with missing values
Imputation: fill with mean, median, mode, or use algorithms like KNN imputation
Indicator variables: add a binary column flagging missingness

In scikit-learn: SimpleImputer(strategy='mean'). The best approach depends on the amount and pattern of missingness. The curse of dimensionality describes problems that arise when data lives in high-dimensional spaces: distances become less meaningful, data becomes sparse, and the volume of space grows exponentially. Effects include degraded nearest-neighbor methods, overfitting, and the need for exponentially more data. Dimensionality reduction (PCA, UMAP) helps.

Question 47 Machine Learning Programming

What is mean squared error (MSE)?

MSE is a common loss function for regression that calculates the average of the squared differences between predicted and actual values: MSE = (1/n) * Σ(y_pred - y_actual)². It penalizes larger errors more heavily due to squaring. In scikit-learn: mean_squared_error(y_true, y_pred). A related metric is RMSE (root of MSE). The exploding gradient problem occurs when gradients grow exponentially during backpropagation, causing unstable weight updates and divergence. Common in deep RNNs. The standard fix is gradient clipping, which caps gradient norms at a threshold. Proper weight initialization and learning rate scheduling also help. Reinforcement learning is a machine learning paradigm where an agent learns to make decisions by performing actions in an environment to maximize a cumulative reward signal. The agent explores actions, receives feedback (reward or penalty), and updates its policy. Examples include game-playing AI (AlphaGo) and robotics control. ANN search trades exactness for massive speedups in finding nearest neighbors in high-dimensional spaces. Algorithms include HNSW, IVF, and LSH. Vector databases implement ANN to support billion-scale retrieval in milliseconds, at the cost of slightly reduced recall.

Question 48 Machine Learning Programming

What is the difference between bagging and boosting?

t-SNE (t-Distributed Stochastic Neighbor Embedding) is a nonlinear dimensionality reduction technique primarily used for visualizing high-dimensional data in 2D or 3D. It preserves local neighborhoods by matching probability distributions over pairwise similarities. Use perplexity (typically 5–50) carefully; t-SNE is for visualization, not feature extraction. The bias-variance tradeoff describes the tension between two sources of error:

Bias: error from overly simple assumptions (underfitting)
Variance: error from sensitivity to small fluctuations in training data (overfitting)

The goal is to find a model complexity that minimizes total error, which is the sum of bias², variance, and irreducible error. Bagging trains multiple models independently in parallel on random subsets of data and combines them (e.g., Random Forest). Boosting trains models sequentially, with each model focusing on the errors of the previous one (e.g., AdaBoost, XGBoost). Bagging reduces variance, while boosting reduces bias. Pruning removes unimportant weights, neurons, or layers from a trained network to reduce size and compute. Magnitude pruning zeros small weights; structured pruning removes whole filters/channels. Combined with fine-tuning, pruning can shrink models by 50–90% with little accuracy loss.

Question 49 Machine Learning Programming

What is a random forest?

PCA is an unsupervised dimensionality reduction technique that transforms data into a new set of orthogonal variables called principal components, ordered by the amount of variance they explain. It reduces the number of features while preserving as much variance as possible. In scikit-learn: PCA(n_components=2).fit_transform(X). A random forest is an ensemble learning method that constructs multiple decision trees during training and outputs the mode (classification) or mean (regression) of the individual trees' predictions. It reduces overfitting by using bagging (bootstrap aggregating) and random feature selection. In scikit-learn: RandomForestClassifier(). A perceptron is the simplest artificial neuron, computing a weighted sum of inputs, adding a bias, and applying a step function as activation. It can only solve linearly separable problems (e.g., AND, OR) but cannot learn XOR. Stacking perceptrons in layers produces a multilayer perceptron (MLP). Adam (Adaptive Moment Estimation) is an optimization algorithm that combines momentum (first moment) with RMSProp-style adaptive learning rates (second moment). It maintains per-parameter learning rates and works well across many deep learning tasks with default hyperparameters (lr=1e-3, beta1=0.9, beta2=0.999).

Question 50 Machine Learning Programming

What is a multilayer perceptron (MLP)?

Bagging trains multiple models independently in parallel on random subsets of data and combines them (e.g., Random Forest). Boosting trains models sequentially, with each model focusing on the errors of the previous one (e.g., AdaBoost, XGBoost). Bagging reduces variance, while boosting reduces bias. An MLP is a fully connected feedforward neural network with one or more hidden layers between the input and output layers. Each neuron applies a non-linear activation, enabling the network to learn complex non-linear mappings. MLPs are the foundation of deep learning and are trained with backpropagation. Label smoothing is a regularization technique that replaces hard one-hot labels with a smoothed distribution (e.g., 0.9 for the true class, 0.1 spread across others). It prevents the model from becoming overconfident, improves calibration, and often boosts generalization in classification and language modeling. Precision measures the proportion of positive predictions that are actually correct: precision = TP / (TP + FP). High precision means the model has a low false positive rate. Precision is important when the cost of false positives is high, such as in spam detection or medical diagnoses.