2024-Q4-AI-M 13. Exam

1. Task

Choose one correct answer.

1. Which statement is correct?

   1. Artificial intelligence nowadays is mostly a complex computer program that mainly consists of programming rules

   2. Artificial intelligence nowadays is mostly a mathematical model that mainly consists of mathematical equations

   3. Artificial intelligence nowadays is mostly a complex computer program that mainly consists of expert knowledge

2. What does artificial intelligence learn from?

   1. Rules created by experts

   2. Data

   3. Rules created by a programmer

3. Which of the following examples could be input data in an artificial intelligence model?

   1. The probability that a client will refuse the service

   2. How many times a client has logged into the system in the last 10 days

   3. The model’s weight values

4. Which of the following examples could be output data in an artificial intelligence model?

   1. The probability that a client will refuse the service

   2. How many times a client has logged into the system in the last 10 days

   3. The model’s weight values

5. To predict a product's price, what type of model is needed?

   1. Regression

   2. Classification

   3. Enumeration

6. To predict whether a client will refuse the service, what type of model is needed?

   1. Regression

   2. Classification

   3. Enumeration

7. In which environment is artificial intelligence usually trained?

   1. Matlab

   2. Python

   3. Power BI

8. What data sets are needed to train a model that could be used in production?

   1. Training set

   2. Test set

   3. Validation set

   4. Training, Test, Validation sets (Train, Test, Validation)

9. Which factor most affects the model's accuracy?

   1. Training rate

   2. Unbalanced sample count in each class in the training dataset

   3. Sample variety in the dataset

10. For which application would artificial intelligence not be effective?

    1. Writing text advertisements

    2. Password and username verification when logging into websites

    3. Creating coloring books for children

    4. Music composition

11. How similar is the artificial deep neural network model to the human natural neural network model?

    1. Almost identical, as evidenced by large language models, image models, and other models

    2. Very similar, because it models biochemical processes as activations are executed

    3. Not similar, because the artificial neural network model is mathematical and executes differently from the human natural neural network

12. Which sequence of actions corresponds to training deep neural network models?

    1. Data normalization, splitting data into sets, model creation, loss function selection, additional metric selection, test cycle, validation cycle, epochs, training cycle, backpropagation

    2. Data normalization, splitting data into sets, model creation, epochs, training cycle, backpropagation, loss function selection, additional metric selection, test cycle, validation cycle

    3. Data normalization, splitting data into sets, model creation, loss function selection, additional metric selection, epochs, training cycle, backpropagation, test cycle, validation cycle

13. What does an epoch mean in the training process of artificial neural networks?

    1. All samples in the training set are considered and there can be many epochs in one training process

    2. A data normalization method that removes extreme values

    3. All samples in the training set are considered and there can be only one epoch in the training process

    4. The validation samples are considered after training

14. If the numerical value of the MSE loss function is 0.5, then after one training step the numerical value will most likely be:

    1. 0.6

    2. 0.5

    3. 0.4

15. RNN is usually used to:

    1. Recognize several objects in an image

    2. Predict stock prices from market data

    3. Predict car prices from an advertisement

16. A ConvNet without data augmentation during training is capable of recognizing:

    1. Objects moved within the image

    2. Objects moved and rotated in the image

    3. Objects moved, enlarged, and rotated in the image

17. The weights W of a pre-trained GRU at each time step:

    1. are different

    2. are the same

    3. are not specified

18. The Transformer model is based on:

    1. The hidden variable vector htht with memory

    2. The attention mechanism

    3. Both

19. Which component is the most important in ChatGPT prompt engineering to achieve a quality answer?

    1. Formulating the prompt as short and precise as possible

    2. Formulating the prompt as long and broad as possible

    3. Copying facts into the prompt

20. What will happen if you continue to ask several questions on different topics one after the other in the same ChatGPT session?

    1. The language model will start copying content from previous questions into later answers

    2. It does not affect the language model's performance

    3. The language model will be overwhelmed and won't know what to answer

21. How does a Denoising Auto-Encoder (DAE) differ from a Variational Auto-Encoder (VAE)?

    1. They differ in input-output data

    2. They differ in the loss function

    3. They differ in that VAE is not trained with SGD (Stochastic Gradient Descent), but uses Variational Inference for training

22. How do UNet and YOLO models differ?

    1. UNet performs semantic segmentation, while YOLO performs object recognition

    2. UNet performs semantic segmentation and can recognize each object separately, but YOLO performs object recognition where all objects of one class are recognized together

    3. UNet performs instance segmentation, while YOLO performs object recognition

23. How does DenseNet differ from ResNet?

    1. ResNet has one skip connection per block using addition, but DenseNet has one skip connection using multiplication

    2. ResNet has one skip connection per block using multiplication, but DenseNet has multiple skip connections connecting several layers forward using multiplication

    3. ResNet has one skip connection per block using addition, but DenseNet has multiple skip connections connecting several layers forward using addition

24. How to encode positional embeddings in a Transformer model?

    1. Using a cosine-sine hard-coded embedding table

    2. Using a trainable embedding table

    3. Both ways

25. What is the dot product of matrices?

    1. A mathematical operation that yields a perpendicular vector or matrix between input vectors

    2. A mathematical operation that performs matrix transformation using multiplication in any dimensions

    3. An algorithm that uses addition and multiplication in the last 2 dimensions in any matrices

26. What is a Linear layer or function in artificial neural networks?

    1. The vector product of a matrix

    2. The scalar multiplication of a matrix and a bias by addition

    3. The linear regression algorithm

27. Why is batch normalization needed before the activation function?

    1. To prevent overfitting

    2. To prevent dead neurons

    3. To prevent bias towards one class in predictions

     

2. Task

List and describe all necessary steps if you were to train a cat and dog photo classifier using PyTorch. You have been given 800 photos of cats and 200 photos of dogs. You cannot use a pre-trained model. You need to create, train, and deploy the model in production, where it will be used to distinguish between photos of cats and dogs. If you mention keywords like “model,” “loss function,” etc., you should use the exact name and description for each “model,” “loss function,” etc., that you will use for this task.

3. Task

Circle the mistakes and write down how they should be correct. Find 10 mistakes

175
1
BATCH_SIZE = 128
2
TRAIN_TEST_SPLIT = 0.8
3
LEARNING_RATE = 200
4
EPOCHS = 100
5

6
class Dataset(torch.utils.data.Dataset):
7
    def __init__(self):
8
        super().__init__()
9
        with open('some_image_dataset.pkl', 'rb') as fp:
10
            X, Y_class_indexes, self.labels = pickle.load(fp)
11
        self.Y_class_indexes = Y_class_indexes
12

13
        X = torch.from_numpy(np.array(X).astype(np.float32))
14
        self.X = X.permute(0, 3, 1, 2)
15
        self.input_size = self.X.size(-1)
16

17
    def __len__(self):
18
        return len(self.X)
19

20
    def __getitem__(self, idx):
21
        x = self.X[idx]
22
        y = self.Y_class_indexes[idx]
23

24
        return x, y
25

26
dataset_full = Dataset()
27
train_test_split = int(len(dataset_full) * TRAIN_TEST_SPLIT)
28

29
idxes_train, idxes_test = sklearn.model_selection.train_test_split(
30
    np.arange(len(dataset_full)),
31
    train_size=train_test_split,
32
    test_size=len(dataset_full) - train_test_split,
33
    stratify=dataset_full.Y_idx,
34
    random_state=0
35
)
36

37
dataloader_train = torch.utils.data.DataLoader(
38
    dataset=dataset_train,
39
    batch_size=BATCH_SIZE,
40
    shuffle=True,
41
    drop_last=(len(dataset_train) % BATCH_SIZE == 1)
42
)
43

44
dataloader_test = torch.utils.data.DataLoader(
45
    dataset=dataset_test,
46
    batch_size=BATCH_SIZE,
47
    shuffle=True
48
)
49

50
def get_out_size(in_size, padding, kernel_size, stride):
51
    return int((in_size + 4 * padding - kernel_size) / stride) + 1
52

53
class Conv2d(torch.nn.Module):
54
    def __init__(self, in_channels, out_channels, kernel_size, stride, padding):
55
        super().__init__()
56
        self.in_channels = in_channels
57
        self.out_channels = out_channels
58
        self.kernel_size = kernel_size
59
        self.stride = stride
60
        self.padding = padding
61
        self.K = torch.nn.Parameter(
62
            torch.FloatTensor(kernel_size, kernel_size, in_channels, out_channels)
63
        )
64

65
    def forward(self, x):
66
        batch_size = x.size(0)
67
        in_size = x.size(-1)
68
        out_size = get_out_size(in_size, self.padding, self.kernel_size, self.stride)
69

70
        out = torch.zeros(batch_size, self.out_channels, out_size, out_size)
71

72
        x_padded = torch.zeros(batch_size, self.in_channels, x_padded_size, x_padded_size)
73
        x_padded_size = in_size + 2 * self.padding
74
        x_padded[:, :, self.padding:-self.padding, self.padding:-self.padding] = x
75

76
        K = self.K.reshape(-1, self.out_channels)
77

78
        i_out = 0
79
        for i in range(0, x_padded_size - self.kernel_size - 1, self.stride):
80
            j_out = 0
81
            for j in range(0, x_padded_size - self.kernel_size - 1, self.stride):
82
                x_part = x_padded[:, :, i:i+self.kernel_size, j:j+self.kernel_size]
83
                x_part = x_part.reshape(batch_size, K.size(0))
84
                out_part = K.t() @ x_part
85
                out[:, :, i_out, j_out] = out_part
86
                j_out += 1
87
            i_out += 1
88

89
        return out
90

91
class Model(torch.nn.Module):
92
    def __init__(self):
93
        super().__init__()
94

95
        self.encoder = torch.nn.Sequential(
96
            Conv2d(in_channels=3, out_channels=5, kernel_size=5, stride=1, padding=1),
97
            torch.nn.BatchNorm2d(num_features=5),
98
            Conv2d(in_channels=5, out_channels=10, kernel_size=5, stride=1, padding=1),
99
            torch.nn.BatchNorm2d(num_features=10),
100
            Conv2d(in_channels=15, out_channels=15, kernel_size=5, stride=1, padding=1),
101
        )
102

103
        out_1 = get_out_size(dataset_full.input_size, kernel_size=5, stride=1, padding=1)
104
        out_2 = get_out_size(out_1, kernel_size=5, stride=1, padding=1)
105
        out_3 = get_out_size(out_2, kernel_size=5, stride=1, padding=1)
106

107
        self.fc = torch.nn.Linear(
108
            in_features=15*out_3*out_3,
109
            out_features=len(dataset_full.labels)
110
        )
111

112
    def forward(self, x):
113
        out = self.encoder.forward(x)
114
        out_flat = out.view(x.size(0), -1)
115
        logits = self.fc.forward(out_flat)
116
        y_prim = torch.softmax(logits, dim=1)
117
        return y_prim
118

119

120
model = Model()
121
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
122

123
metrics = {}
124
for stage in ['train', 'test']:
125
    for metric in [
126
        'loss',
127
        'acc'
128
    ]:
129
        metrics[f'{stage}_{metric}'] = []
130

131
for epoch in range(1, EPOCHS):
132
    for data_loader in [dataloader_train, dataloader_test]:
133
        metrics_epoch = {key: [] for key in metrics.keys()}
134

135
        if data_loader == dataloader_test:
136
            stage = 'test'
137
            model = model.eval()
138
            torch.set_grad_enabled(False)
139
        else:
140
            stage = 'train'
141
            model = model.train()
142
            torch.set_grad_enabled(True)
143

144
        for x, y in tqdm(data_loader):
145

146
            y_prim = model.forward(x)
147

148
            y_idx = y.cpu().data.numpy().argmax(axis=-1)
149
            loss = torch.mean(y * torch.log(y_prim + 1e-8))
150

151
            if data_loader == dataloader_train:
152
                loss.backward()
153
                optimizer.zero_grad()
154
                optimizer.step()
155

156
            np_y_prim = y_prim.cpu().data.numpy()
157
            np_y = y.cpu().data.numpy()
158

159
            idx_y = np.argmax(np_y, axis=1)
160
            idx_y_prim = np.argmax(np_y_prim, axis=1)
161

162
            acc = np.average((idx_y == idx_y_prim) * 1.0)
163

164
            metrics_epoch[f'{stage}_acc'].append(acc)
165
            metrics_epoch[f'{stage}_loss'].append(loss.cpu().item())
166

167
        metrics_strs = []
168
        for key in metrics_epoch.keys():
169
            if stage in key:
170
                value = np.mean(metrics_epoch[key])
171
                metrics[key].append(value)
172
                metrics_strs.append(f'{key}: {round(value, 2)}')
173

174

175