Home / Past papers / MLP End Term / this paper

IIT M FOUNDATION FN EXAM FDF1 24 Dec 2023 - 24 Dec 2023

MLP End Term38 questions100 marks22 MCQ · 11 MSQ · 5 SAFoundation / forenoon

Elapsed 00:00

Q1MCQ2 marks

Consider the following Python code using Pandas: question figure

Consider the following Python code using Pandas: What does the groupby operation in the code achieve?

It calculates the total price for each category.
It calculates the average price for each category.
It groups the data by the ’Category’ column.
It filters out rows where the ’Price’ column is zero.

Q2MCQ2 marks

Q3MCQ2 marks

Which of the following metrics indicate higher their value, better the regression model’s performance?

RMSE
R2
Mean absolute error
Mean squared error

Q4MCQ2 marks

Which of the following variations of gradient descent can be implemented with SGDClassifier?

stochastic gradient descent
mini gradient descent
full batch gradient descent
None of these

Q5MCQ2 marks

Consider the Ridge regression model in scikit-learn, represented by the Ridge class. Which of the following statements about Ridge regression is correct?

Ridge regression is designed to handle class imbalance of the dataset.
The regularization term in Ridge regression is added to the sum of absoluteresiduals.
Increasing the value of the regularization parameter (alpha) in Ridgeregression makes the model less sensitive to high-magnitude coefficients.
Ridge regression is equivalent to Lasso regression when the regularizationparameter (alpha) is set to zero.

Q6MCQ2 marks

Which of the following method is used to estimate the probabilities in SGD-Classifier with suitable loss?

Q7MCQ2 marks

Faster to compute the list of neighbors on scaled data.
k-nearest neighbors is based on computing some distances. Features need tobe normalized to contribute approximately equally to the distance computation.
Scaling the data has a negligible effect on k-nearest neighbor’s performance,but it enhances the interpretability of the model.
This is irrelevant. One could use k-nearest neighbors without normalizing thedataset and get a very similar cross-validation score.

Q8MCQ2 marks

When using CountVectorizer in scikit-learn, what does the max_features parameter control?

The maximum number of documents considered during vectorization.
The maximum number of features (words) to be extracted based on termfrequency.
The maximum number of randomly selected features (words).
The maximum number of characters allowed in each document.

Q9MCQ2 marks

Which of these may NOT help in handling overfitting in decision trees?

Increasing the value of min_samples_split
Increasing the value of the pruning parameter
Increasing the value of min_samples_leaf
Increasing the depth of the tree

Q10MCQ2 marks

Which of the following is/are Clustering Method.

Connectivity-based Clustering
Centroids-based Clustering
Density-based Clustering
All of them

Q11MCQ2 marks

You’re working with a large image and want to group similarly coloured segments in the image together. No other information is provided with the image. Which of the following techniques will you use to accomplish the task?

Supervised learning
Unsupervised learning
Reinforcement learning
None of these

Q12MCQ2 marks

logistic
relu
identity
tanh

Q13MCQ3 marks

[5, 5, 3.75]
[5, 5, 3]
[4, 4, 3]
[4, 4, 3.75]

Q14MCQ3 marks

Q15MCQ3 marks

Which of the following code snippets represent correct methods to obtain cross validated performance measure using LeaveOneOut?

Q16MCQ3 marks

(71)
(71, 1)
(10)
(10, 2)

Q17MCQ3 marks

You’re building an ‘MLPClassifier‘ for a dataset with a large number of features. The goal is to predict whether a patient is going to have parkinson disease in next 12 months. You’re trying to decide the appropriate number of neurons in the hidden layers of the neural network. Which statement about adjusting the hidden_layer_sizes parameter is correct?

Increasing the number of neurons in hidden layers will always lead to bettermodel performance.
Decreasing the number of neurons in hidden layers reduces the model’scapacity to capture complex patterns.
The number of neurons in hidden layers does not significantly affect themodel’s performance.
Finding the optimal number of neurons is a trial-and-error process and mayrequire experimentation.

Q18MCQ3 marks

Which of the following code snippet can correctly plot the elbow graph for feature matrix X (k value is taken from 1 to 10)?

Q19MCQ3 marks

Increasing the model’s complexity to fit the training data more closely.
Adding a stronger regularization term to the loss function, discouragingcomplex models.
Making the model more capable to learn more complex behaviour.
Adjusting the learning rate to control convergence speed.

Q20MCQ4 marks

Output score is likely to increase.
Output score is likely to decrease.
Output score may increase or decrease.
Output score will remain the same.

Q21MCQ4 marks

Q22MCQ4 marks

Above code uses bootstrapping to generate samples for each base classifier.
model will be tested on out of the bags samples.
Due to weights=’distance’, each base KNN classifier will treat all neighborsequally in terms of voting power.
The ensemble will consist of 3 base KNN classifiers.
None of these

Q23MSQ2 marksselect all that apply

Consider a dataset representing various attributes of red wine, loaded into a Pandas DataFrame named data using the following code: question figure

Consider a dataset representing various attributes of red wine, loaded into a Pandas DataFrame named data using the following code: Suppose we are interested in extracting the value of the chlorides attribute for the third sample in the dataset (2nd by index). Which of the following expressions correctly achieves this? chlorides is at the 4th index of columns.

data.chlorides[2]
data[’chlorides’][2]
data[2][4]
data.iloc[2, 4]

Q24MSQ2 marksselect all that apply

It applies lasso penalty.
The training may terminate after 499 iterations or lesser
the classifier represents a perceptron model
The classifier’s model parameters will initialized with parameters learnt fromprevious call to fit() function, if the same object is trained/fitted multiple times on new data.

Q25MSQ2 marksselect all that apply

Which of the following observations warrant use of SGD model?

The data set size is 1000 GB.
The model has to be trained in non-iterative manner.
The model must be a decision tree.
The model must be a logistic regressor.
None of these

Q26MSQ2 marksselect all that apply

Q27MSQ2 marksselect all that apply

‘poly’,
‘lasso’
‘rbf’,
‘scale’

Q28MSQ3 marksselect all that apply

malic_acid
magnesium
flavanoids
proanthocyanins
color_intensity
proline

Q29MSQ3 marksselect all that apply

Q30MSQ3 marksselect all that apply

[47, 31, 18, 95, 77]
[47, 31, 18 ]
[31, 41, 18, 95, 85, 77]
[31, 41, 85, 31]
[18, 95, 85, 77]
[47, 31, 18, 85]
None of these

Q31MSQ3 marksselect all that apply

When using a Support Vector Classifier (SVC) in scikit-learn with different values of the regularization parameter (C), how does the complexity of the decision boundary change? Select all correct statements:

Smaller values of C result in a more complex decision boundary.
Larger values of C result in a more complex decision boundary.
The decision boundary becomes simpler with increasing values of C.
Very large values of C may lead to overfitting.

Q32MSQ4 marksselect all that apply

Number of samples at node N = 10. If it is split, it will result in 2 nodes in theleft child and 8 nodes in the right child.
Number of samples at node N = 6. If it is split, it will result in 3 nodes in the leftchild and 3 nodes in the right child.
Number of samples at node N = 12. If it is split, it will result in 5 nodes in theleft child and 7 nodes in the right child.
Number of samples at node N = 4. If it is split, it will result in 3 nodes in the leftchild and 1 node in the right child.

Q33SA3 marks

Your numeric answer:

Q34SA3 marks

Your numeric answer:

Q35SA2 marks

Your numeric answer:

Q36SA4 marks

Your numeric answer:

Comprehension passage - the questions below it refer to this

Based on the above data, answer the given subquestions. question figure

Q37SA3 marks

How many Accidents per 1000 Driver happens for Age 25 and driving blue car ?

Your numeric answer:

Q38MSQ2 marksselect all that apply

To improve the given model which of the following preprocessing step you suggest?

StandardScaler()
OrdinalEncoder()
MinMaxScaler()
LabelEncoder()

Answer key

Q1 (MCQ, 2 marks): B
Q2 (MCQ, 2 marks): D
Q3 (MCQ, 2 marks): B
Q4 (MCQ, 2 marks): A
Q5 (MCQ, 2 marks): C
Q6 (MCQ, 2 marks): A
Q7 (MCQ, 2 marks): B
Q8 (MCQ, 2 marks): B
Q9 (MCQ, 2 marks): D
Q10 (MCQ, 2 marks): D
Q11 (MCQ, 2 marks): B
Q12 (MCQ, 2 marks): C
Q13 (MCQ, 3 marks): B
Q14 (MCQ, 3 marks): B
Q15 (MCQ, 3 marks): A
Q16 (MCQ, 3 marks): C
Q17 (MCQ, 3 marks): D
Q18 (MCQ, 3 marks): C
Q19 (MCQ, 3 marks): C
Q20 (MCQ, 4 marks): A
Q21 (MCQ, 4 marks): B
Q22 (MCQ, 4 marks): E
Q23 (MSQ, 2 marks): A, B, D
Q24 (MSQ, 2 marks): B, D
Q25 (MSQ, 2 marks): A, D
Q26 (MSQ, 2 marks): A, C
Q27 (MSQ, 2 marks): A, C
Q28 (MSQ, 3 marks): C, E, F
Q29 (MSQ, 3 marks): A, C, D
Q30 (MSQ, 3 marks): A, B, C, D
Q31 (MSQ, 3 marks): B, D
Q32 (MSQ, 4 marks): A, D
Q33 (SA, 3 marks): 0.6
Q34 (SA, 3 marks): 1
Q35 (SA, 2 marks): 2
Q36 (SA, 4 marks): 500
Q37 (SA, 3 marks): 73 to 75
Q38 (MSQ, 2 marks): A, C

Concepts this paper tests

Auto-generated summary from the source site. Handy as a checklist; the lessons above explain each idea from scratch.

Here’s a structured summary of core topics, concepts, principles, and equations essential for the Diploma Level: Machine Learning Practice (Computer-Based Exam). The summary is organized by domains (e.g., Data Preprocessing, Supervised Learning, Unsupervised Learning, Model Evaluation, etc.), followed by key equations (where applicable) and Mermaid knowledge graphs to visualize relationships.

1. Core Topics & Concepts

A. Data Preprocessing

Key Concepts:

Handling Missing Data
- SimpleImputer (mean/median/mode imputation).
- Equation for mean imputation:

\text{Imputed value} = \frac{1}{n} \sum_{i=1}^n x_i \quad \text{(for column } j\text{)}

Example: si.statistics_ returns the mean/median of each column.

Feature Scaling
- StandardScaler: Standardizes features to have mean=0 and variance=1.

z = \frac{x - \mu}{\sigma}

MinMaxScaler: Scales features to a range (e.g., [0, 1]).

x_{\text{scaled}} = \frac{x - \min(X)}{\max(X) - \min(X)}

Why scale?
- Critical for distance-based algorithms (e.g., KNN, SVM, Neural Networks).
- Prevents features with larger magnitudes from dominating.

Categorical Encoding
- One-Hot Encoding: Converts categorical variables into binary columns.
  - Example: Car_color → Black, Blue, Red (binary columns).
- Ordinal Encoding: Assigns integers to categories (use if ordinal relationship exists).
- Label Encoding: Assigns integers to categories (not recommended for nominal data).

Feature Selection
- SelectKBest: Selects top-k features based on statistical tests (e.g., chi-squared, ANOVA).
- Example: SelectKBest(chi2, k=3) selects the 3 best features based on chi-squared scores.

B. Supervised Learning

Key Concepts:

Linear Models
- Logistic Regression:
  - Outputs probabilities via sigmoid function:

P(y=1) = \frac{1}{1 + e^{-(\beta_0 + \beta_1 x_1 + \dots + \beta_n x_n)}}

Loss: Log loss (cross-entropy).
- Ridge Regression (L2 Regularization):
Loss function:

\text{MSE} + \alpha \sum_{i=1}^n \beta_i^2

Effect of α: Higher α → more penalty on large coefficients (prevents overfitting).
- Lasso Regression (L1 Regularization):
Loss function:

\text{MSE} + \alpha \sum_{i=1}^n |\beta_i|

Can shrink coefficients to exactly 0 (feature selection).

Support Vector Machines (SVM)
- Linear SVM:
  - Decision function: $f(x) = \text{sign}(w^T x + b)$ .
  - Regularization (C): Smaller C → wider margin (simpler model).
- Kernel Trick:
  - Transforms data into higher dimensions for non-linear separation.
  - Common kernels: linear, poly, rbf, sigmoid.

Decision Trees
- Splitting Criteria:
  - Gini impurity (for classification):

G = 1 - \sum_{i=1}^c p_i^2

Entropy (for classification):

H = -\sum_{i=1}^c p_i \log(p_i)

Hyperparameters:
- max_depth: Maximum depth of the tree.
- min_samples_split: Minimum samples required to split a node.
- min_samples_leaf: Minimum samples required at a leaf node.
Overfitting: Deeper trees → higher variance. Prune with max_depth or min_samples_leaf.

Neural Networks (MLP)
- Architecture:
  - Input layer → Hidden layer(s) → Output layer.
  - Number of parameters for 1 hidden layer:

(n_{\text{input}} \times n_{\text{hidden}}) + n_{\text{hidden}} + (n_{\text{hidden}} \times n_{\text{output}}) + n_{\text{output}}

Activation Functions:
- Hidden layers: relu, tanh, logistic.
- Output layer:
  - Regression: identity.
  - Binary classification: logistic.
  - Multiclass classification: softmax.
Regularization (α):
- Higher α → stronger L2 penalty (prevents overfitting).

Stochastic Gradient Descent (SGD)
- Loss Functions:
  - hinge: SVM.
  - log_loss: Logistic regression.
  - squared_error: Linear regression.
- Penalties:
  - l1 (Lasso), l2 (Ridge), elasticnet.
- Key Parameters:
  - learning_rate: Step size for updates.
  - max_iter: Maximum epochs.
  - warm_start: Reuse previous solution for incremental learning.

C. Unsupervised Learning

Key Concepts:

Clustering
- K-Means:
  - Objective: Minimize inertia (within-cluster sum of squares):

\text{Inertia} = \sum_{i=1}^n \min_{\mu_j \in C} ||x_i - \mu_j||^2

Elbow Method: Plot inertia vs. k to find optimal clusters.
- Types of Clustering:
Centroid-based (K-Means).
Density-based (DBSCAN).
Connectivity-based (Hierarchical).

Dimensionality Reduction
- PCA (Principal Component Analysis):
  - Transforms data to orthogonal components (ordered by variance).
  - First PC: Direction of maximum variance.

D. Model Evaluation & Hyperparameter Tuning

Key Concepts:

Evaluation Metrics
- Classification:
  - Accuracy, Precision, Recall, F1-score, ROC-AUC.
- Regression:
  - R² (R-squared): Higher is better (1 = perfect fit).

R^2 = 1 - \frac{\text{SS}_{\text{res}}}{\text{SS}_{\text{tot}}}

RMSE/MSE/MAE: Lower is better.

\text{RMSE} = \sqrt{\frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2}

Cross-Validation
- K-Fold CV: Splits data into k folds; trains on k-1 folds, tests on 1.
- Leave-One-Out (LOO): Extreme case of K-Fold where k = n (computationally expensive).
- Stratified K-Fold: Preserves class distribution in each fold.

Hyperparameter Tuning
- GridSearchCV: Exhaustive search over specified parameter values.
- RandomizedSearchCV: Randomly samples parameter combinations (faster for large spaces).
- Example:
```
param_grid = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
grid_search = GridSearchCV(SVC(), param_grid, cv=5)
```

Bias-Variance Tradeoff
- Underfitting (High Bias): Model is too simple (increase complexity).
- Overfitting (High Variance): Model memorizes noise (regularize, prune, or get more data).

E. Ensemble Methods

Key Concepts:

Bagging (Bootstrap Aggregating)
- Random Forest: Ensemble of decision trees trained on bootstrapped samples.
- Reduces variance by averaging predictions.

Boosting
- Gradient Boosting: Sequentially corrects errors of previous models.
- AdaBoost: Weights misclassified samples higher in subsequent iterations.

Voting Classifier
- Hard Voting: Majority class from multiple models.
- Soft Voting: Average probabilities from multiple models.

F. Practical Scenarios

Scenario	Recommended Approach
Large dataset (1000+ GB)	SGDClassifier (incremental learning)
Non-linear decision boundary	Kernel SVM or Neural Networks
High-dimensional data	Ridge Regression or PCA + Linear Model
Imbalanced classes	Adjust class weights or use SMOTE
Feature importance needed	Random Forest or Lasso Regression
Clustering similar items	K-Means (if spherical clusters) or DBSCAN

2. Key Equations Summary

Concept	Equation
Standard Scaling	$z = \frac{x - \mu}{\sigma}$
MinMax Scaling	$x_{\text{scaled}} = \frac{x - \min(X)}{\max(X) - \min(X)}$
Logistic Regression	$P(y=1) = \frac{1}{1 + e^{-(\beta_0 + \beta_1 x_1 + \dots + \beta_n x_n)}}$
Ridge Regression	$\text{MSE} + \alpha \sum_{i=1}^n \beta_i^2$
Lasso Regression	$\text{MSE} + \alpha \sum_{i=1}^n \|\beta_i\|$
K-Means Inertia	$\sum_{i=1}^n \min_{\mu_j \in C} \|\|x_i - \mu_j\|\|^2$
R² Score	$R^2 = 1 - \frac{\text{SS}_{\text{res}}}{\text{SS}_{\text{tot}}}$
RMSE	$\sqrt{\frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2}$
Gini Impurity	$G = 1 - \sum_{i=1}^c p_i^2$
Entropy	$H = -\sum_{i=1}^c p_i \log(p_i)$
MLP Parameters (1 hidden)	$(n_{\text{input}} \times n_{\text{hidden}}) + n_{\text{hidden}} + (n_{\text{hidden}} \times n_{\text{output}}) + n_{\text{output}}$

Graph 2: Supervised Learning Algorithms

Graph 3: Unsupervised Learning

Graph 4: Model Evaluation Metrics

Graph 5: Hyperparameter Tuning

4. Exam Tips

Pandas Operations:
- groupby().mean() → Calculates average per group.
- df.iloc[row, col] → Access by integer position.
- df['column'][index] → Access column by name and row by index.

Scikit-Learn Syntax:
- fit() → Train the model.
- predict() → Generate predictions.
- predict_proba() → Class probabilities (for classifiers).
- score() → Returns accuracy (for classifiers) or R² (for regressors).

Common Pitfalls:
- Forgetting to scale data for distance-based models (KNN, SVM, Neural Networks).
- Misinterpreting alpha in Ridge/Lasso (higher α = stronger regularization).
- Confusing min_samples_split and min_samples_leaf in decision trees.

Key Takeaways:
- Overfitting: Mitigate with regularization, pruning, or cross-validation.
- Underfitting: Increase model complexity or add features.
- Feature Importance: Use coef_ (linear models) or feature_importances_ (tree-based models).

5. Quick Reference Table

Topic	Key Points
StandardScaler	Mean=0, Std=1; use for distance-based models.
Ridge vs. Lasso	Ridge: L2 (shrinks coefficients); Lasso: L1 (can zero coefficients).
SGDClassifier	Use `loss='hinge'` for SVM, `loss='log_loss'` for logistic regression.
K-Means	Elbow method to choose k; inertia = within-cluster sum of squares.
Decision Trees	`max_depth` controls complexity; deeper trees risk overfitting.
Neural Networks	`hidden_layer_sizes=(10,)` for 1 hidden layer with 10 neurons.
Cross-Validation	`cv=5` in `GridSearchCV` → 5-fold cross-validation.
Voting Classifier	`voting='soft'` for probability averaging; `'hard'` for majority class.
Imbalanced Data	Use `class_weight='balanced'` or SMOTE.
PCA	Reduces dimensions; first component = max variance direction.