General Concepts In Machine Learning

1. What’s the risk in empirical risk minimization?
2. Why is it empirical?
3. How do we minimize that risk?

1. What are the differences between parameters and hyper-parameters?
2. Why is hyperparameter tuning important?
3. List down methods for tuning hyper-parameters.

1. What makes a classification problem different from a regression problem?
2. Can a classification problem be turned into a regression problem and vice versa?

1. What’s the difference between parametric methods and non-parametric methods? Give an example of each method.
2. When should we use one and when should we use the other?

1. What are your hypotheses about the causes?
2. How do you validate whether your hypotheses are correct?
3. Imagine your hypotheses about the causes are correct. What would you do to address them?

        skf = StratifiedKFold(y, n_folds=5, random_state=989, shuffle=True)
        ```
2. Explain the benefits of using the K-fold cross validation approach.
3. Explain the benefits of using the Stratified K-fold cross validation approach.
4. State the difference between K-fold cross validation and stratified cross validation.
5. Explain in your own words what is meant by “We adopted a 5-fold cross-validation approach to estimate the testing error of the model”.

$CV_k = \frac{1}{k}\sum_{i=1}^{k}MSE_i$

1. A 5-fold cross-validation approach results in 5-different model instances being fitted.
2. A 5-fold cross-validation approach results in 1 model instance being fitted over and over again 5 times.
3. A 5-fold cross-validation approach results in 5-different model instances being fitted over and over again 5 times.
4. Uses K-different data-folds.

1. We compute the cross-validation performance as the arithmetic mean over the K performance estimates from the validation sets.
2. We compute the cross-validation performance as the best one over the K performance estimates from the validation sets.

1. True or false: It is always possible to find an optimal value $n$,$K = n$ in K-fold cross-validation.

    import torchvision.models as models
    ...
    res_model = models.resnet34(pretrained=True)
    ```
    He then applies the following algorithm, entitled xxx on the image.
    ```python
    import math
    def xxx(arr):
        mod = 0.0
        for i in arr:
            mod += i * i
        mag = math.sqrt(mod)
        for i in range(len(arr)):
            arr[i] /= mag
    # Example usage:
    arr = [1.0, 2.0, 3.0]
    xxx(arr)
    print(arr)
    ```
Which results in this list:
<table align='center'>
<tr>
    <td align="center">
    <img src="img/similarity-1.png" style="max-width:70%;" />
    </td>
</tr>
</table>
Name the algorithm that he used and explain in detail why he used it.

Algo 1 Data: Two vectors v1 and v2 are provided Apply algorithm xxx on the two vectors Run algorithm 2 Algo 2

def algo2(v1, v2):
    mul = 0.0
    for i in range(len(v1)):
        mul += v1[i] * v2[i]
    if mul < 0:
        return 0
    return mul

1. Name the algorithm algo2 that he used and explain in detail what he used it for.
2. Write the mathematical formulae behind it.
3. What are the minimum and maximum values it can return?
4. An alternative similarity measures between two vectors is: $\text{simeuc}(v1, v2) = -\|v1 - v2\|$. Name the measure.

2. Explain the formulae in plain words.
3. Find the Jacard similarity given the sets.

The Kullback-Leibler divergence is a meas- ure of how different two probability distribution are. As noted, the KL divergence of the probability distributions P, Q on a set X is defined as shown in Equation 8.11. $D_{KL}(P \| Q) = \sum_{x \in X} P(x) \log\left(\frac{P(x)}{Q(x)}\right)$ Note however that since KL divergence is a non-symmetric information theoretical meas- ure of distance of P from Q, then it is not strictly a distance metric. During the past years, various KL based distance measures (rather than divergence based) have been introduced in the literature generalizing this measure. Name each of the following KL based distances: $D_{KLD1}(P \| Q) = D_{KL}(P \| Q) + D_{KL}(Q \| P)$ $D_{KLD2}(P \| Q) = \sum_{x \in X} (P(x) - Q(x)) \log(P(x))$ $D_{KLD3}(P \| Q) = \frac{1}{2} [D_{KL}\left(Q\|\right(\frac{P+Q}{2})) + D_{KL}\left(P\|\right(\frac{P+Q}{2})) ]$ $D_{KLD4}(P \| Q) = max(D_{KL}\left(Q\|\right(P)) + D_{KL}\left(P\|\right(Q)))$

1. How would you sample $100K$ comments to label?
   1. Suppose you get back $100K$ labeled comments from $20$ annotators and you want to look at some labels to estimate the quality of the labels. How many labels would you look at? How would you sample them?

1. When should you remove duplicate training samples? When shouldn’t you?
2. What happens if we accidentally duplicate every data point in your train set or in your test set?

1. In your dataset, two out of 20 variables have more than 30% missing values. What would you do?
2. How might techniques that handle missing data make selection bias worse? How do you handle this bias?

1. How would class imbalance affect your model?
2. Why is it hard for ML models to perform well on data with class imbalance?
3. Imagine you want to build a model to detect skin legions from images. In your training dataset, only $1$ of your images shows signs of legions. After training, your model seems to make a lot more false negatives than false positives. What are some of the techniques you'd use to improve your model?

1. Imagine you're working with a binary task where the positive class accounts for only 1% of your data. You decide to oversample the rare class then split your data into train and test splits. Your model performs well on the test split but poorly in production. What might have happened?
2. You want to build a model to classify whether a comment is spam or not spam. You have a dataset of a million comments over the period of 7 days. You decide to randomly split all your data into the train and test splits. Your co-worker points out that this can lead to data leakage. How?

1. What are some causes of feature leakage?
2. Why does normalization help prevent feature leakage?
3. How do you detect feature leakage?

1. When we say an algorithm converges, what does convergence mean?
2. How do we know when a model has converged?

1. What’s the bias-variance trade-off?
2. How’s this tradeoff related to overfitting and underfitting?
3. How do you know that your model is high variance, low bias? What would you do in this case?
4. How do you know that your model is low variance, high bias? What would you do in this case?

1. Explain different methods for cross-validation.
2. Why don’t we see more cross-validation in deep learning?

1. What’s wrong with training and testing a model on the same data?
2. Why do we need a validation set on top of a train set and a test set?
3. Your model’s loss curves on the train, valid, and test sets look like this. What might have been the cause of this? What would you do?

1. Why do we use feature selection?
2. What are some of the algorithms for feature selection? Pros and cons of each.