Специалист по глубокому обучению (Профессиональный уровень)

Экзаменационный билет №1

Теоретическая часть:

1. Опишите архитектуру и принцип работы LSTM. Какие компоненты она включает и как они взаимодействуют между собой?
   Ответ: LSTM (Long Short-Term Memory) — это разновидность RNN, предназначенная для обработки последовательностей и сохранения долгосрочной зависимости. Архитектура включает три ключевых элемента: входной вентиль (input gate), вентиль забывания (forget gate) и выходной вентиль (output gate). Входной вентиль определяет, какие новые данные будут добавлены в ячейку памяти. Вентиль забывания решает, какие данные из предыдущего состояния следует удалить. Выходной вентиль контролирует, какие части текущего состояния ячейки будут переданы на выход.

2. Что такое dropout и как он помогает бороться с переобучением?
   Ответ: Dropout — это метод регуляризации, при котором случайные нейроны отключаются во время обучения. Это заставляет модель не полагаться слишком сильно на конкретные нейроны, тем самым улучшая обобщающую способность и снижая вероятность переобучения.

Практическая часть:

3. Реализуйте простую свёрточную сеть (CNN) с использованием PyTorch для классификации набора данных CIFAR-10. Сеть должна содержать минимум два сверточных слоя и один полносвязный выходной слой.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.optim as optim
   import torchvision
   import torchvision.transforms as transforms
   
   class SimpleCNN(nn.Module):
       def __init__(self):
           super(SimpleCNN, self).__init__()
           self.features = nn.Sequential(
               nn.Conv2d(3, 32, kernel_size=3, padding=1),
               nn.ReLU(),
               nn.MaxPool2d(kernel_size=2),
               nn.Conv2d(32, 64, kernel_size=3, padding=1),
               nn.ReLU(),
               nn.MaxPool2d(kernel_size=2)
           )
           self.classifier = nn.Sequential(
               nn.Flatten(),
               nn.Linear(64 * 8 * 8, 512),
               nn.ReLU(),
               nn.Linear(512, 10)
           )
   
       def forward(self, x):
           x = self.features(x)
           x = self.classifier(x)
           return x
   
   # Загрузка данных
   transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
   trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
   trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
   
   # Инициализация модели, функции потерь и оптимизатора
   model = SimpleCNN()
   criterion = nn.CrossEntropyLoss()
   optimizer = optim.Adam(model.parameters(), lr=0.001)
   
   # Обучение модели
   for epoch in range(2):  # Пример с двумя эпохами
       for inputs, labels in trainloader:
           optimizer.zero_grad()
           outputs = model(inputs)
           loss = criterion(outputs, labels)
           loss.backward()
           optimizer.step()
       print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')

Экзаменационный билет №2

Теоретическая часть:

1. Опишите, как работает механизм внимания (attention) в модели Transformer и зачем он нужен?
   Ответ: Механизм внимания в Transformer позволяет модели фокусироваться на наиболее релевантных частях входной последовательности при обработке текущего токена. В частности, self-attention вычисляет взаимосвязи между всеми парами токенов, что обеспечивает учёт контекста. Это устраняет необходимость рекуррентных связей и делает модель более параллелизуемой.

2. Что такое transfer learning и в каких случаях его стоит применять?
   Ответ: Transfer learning — это подход, при котором предобученная модель используется как основа для новой задачи. Применяется, когда объем доступных данных мал или вычислительные ресурсы ограничены. Замораживают часть слоёв и дообучают верхние слои под конкретную задачу.

Практическая часть:

3. Реализуйте обучение линейной регрессии с помощью PyTorch без использования высокоуровневых API (например, nn.Linear, optim.Adam), используя только torch.Tensor и автоматическое дифференцирование. Обучите модель на случайно сгенерированных данных.
   Ответ:

   import torch
   
   # Генерация данных
   X = torch.randn(100, 1)
   y = 3 * X + 2 + 0.1 * torch.randn(X.shape)
   
   # Инициализация параметров
   w = torch.randn(1, requires_grad=True)
   b = torch.randn(1, requires_grad=True)
   
   # Параметры обучения
   lr = 0.01
   epochs = 100
   
   # Обучение
   for epoch in range(epochs):
       y_pred = X.mm(w) + b
       loss = ((y_pred - y) ** 2).mean()
       loss.backward()
       
       with torch.no_grad():
           w -= lr * w.grad
           b -= lr * b.grad
           w.grad.zero_()
           b.grad.zero_()
       
       if (epoch+1) % 10 == 0:
           print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')
           
   print(f'Итоговая модель: y = {w.item():.2f}x + {b.item():.2f}')

Экзаменационный билет №3

Теоретическая часть:

1. Объясните, что такое batch normalization и как он влияет на обучение нейронной сети?
   Ответ: Batch normalization — это метод нормализации выходов слоёв по батчам, что ускоряет обучение и улучшает стабильность. Он уменьшает проблему внутреннего ковариационного сдвига, позволяет использовать более высокие скорости обучения и снижает зависимость от начальной инициализации весов.

2. Что такое GAN и как происходит процесс обучения генератора и дискриминатора?
   Ответ: GAN (Generative Adversarial Network) состоит из двух моделей: генератора и дискриминатора. Генератор создаёт фейковые данные, пытаясь обмануть дискриминатор, а тот учится отличать реальные данные от сгенерированных. Процесс обучения ведётся через минимаксную игру, где обе модели совершенствуются поочерёдно.

Практическая часть:

3. Реализуйте простой GAN для генерации одномерных данных с использованием PyTorch.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.optim as optim
   
   # Определение генератора
   class Generator(nn.Module):
       def __init__(self):
           super(Generator, self).__init__()
           self.model = nn.Sequential(
               nn.Linear(10, 25),
               nn.ReLU(),
               nn.Linear(25, 1)
           )
   
       def forward(self, x):
           return self.model(x)
   
   # Определение дискриминатора
   class Discriminator(nn.Module):
       def __init__(self):
           super(Discriminator, self).__init__()
           self.model = nn.Sequential(
               nn.Linear(1, 25),
               nn.ReLU(),
               nn.Linear(25, 1),
               nn.Sigmoid()
           )
   
       def forward(self, x):
           return self.model(x)
   
   # Инициализация моделей
   G = Generator()
   D = Discriminator()
   
   # Оптимизаторы
   opt_G = optim.Adam(G.parameters(), lr=0.001)
   opt_D = optim.Adam(D.parameters(), lr=0.001)
   
   # Функция потерь
   criterion = nn.BCELoss()
   
   # Обучение
   for epoch in range(1000):
       # Обучение дискриминатора
       real_data = torch.randn(64, 1)
       real_labels = torch.ones(real_data.size(0), 1)
       
       noise = torch.randn(64, 10)
       fake_data = G(noise).detach()
       fake_labels = torch.zeros(fake_data.size(0), 1)
       
       outputs_real = D(real_data)
       loss_real = criterion(outputs_real, real_labels)
       
       outputs_fake = D(fake_data)
       loss_fake = criterion(outputs_fake, fake_labels)
       
       loss_D = loss_real + loss_fake
       
       opt_D.zero_grad()
       loss_D.backward()
       opt_D.step()
       
       # Обучение генератора
       noise = torch.randn(64, 10)
       fake_data = G(noise)
       outputs = D(fake_data)
       loss_G = criterion(outputs, torch.ones(outputs.size(0), 1))
       
       opt_G.zero_grad()
       loss_G.backward()
       opt_G.step()
       
       if (epoch+1) % 100 == 0:
           print(f'Epoch {epoch+1}, Loss D: {loss_D.item():.4f}, Loss G: {loss_G.item():.4f}')

Экзаменационный билет №4

Теоретическая часть:

1. Что такое self-supervised learning и в чём его отличие от supervised и unsupervised обучения?
   Ответ: Self-supervised learning — это метод, при котором обучение происходит без явной разметки, но не просто на основе структуры данных (как в unsupervised), а с использованием предтекстовых задач, извлекающих supervisory сигнал из самих данных. Например, маскировка токенов (BERT) или сравнение положительных и отрицательных пар (SimCLR). В отличие от supervised, он не требует меток; в отличие от unsupervised, формирует представления через целевую задачу.

2. Как работает алгоритм backpropagation и как он связан с градиентным спуском?
   Ответ: Backpropagation — это метод вычисления градиентов функции потерь по параметрам модели с использованием цепного правила дифференцирования. Градиенты затем используются в градиентном спуске для обновления весов. Таким образом, backpropagation обеспечивает теоретическую основу для корректировки параметров модели в направлении минимизации ошибки.

Практическая часть:

3. Реализуйте простой autoencoder для сжатия и восстановления данных MNIST с помощью PyTorch. Обучите модель и визуализируйте оригинальные и реконструированные изображения.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.optim as optim
   from torchvision import datasets, transforms
   import matplotlib.pyplot as plt
   
   # Определение autoencoder
   class Autoencoder(nn.Module):
       def __init__(self):
           super(Autoencoder, self).__init__()
           self.encoder = nn.Sequential(
               nn.Linear(28*28, 128),
               nn.ReLU(),
               nn.Linear(128, 64),
               nn.ReLU(),
               nn.Linear(64, 12)
           )
           self.decoder = nn.Sequential(
               nn.Linear(12, 64),
               nn.ReLU(),
               nn.Linear(64, 128),
               nn.ReLU(),
               nn.Linear(128, 28*28),
               nn.Sigmoid()
           )
   
       def forward(self, x):
           x = self.encoder(x)
           x = self.decoder(x)
           return x
   
   # Подготовка данных
   transform = transforms.ToTensor()
   train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
   train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
   
   # Инициализация модели
   model = Autoencoder()
   criterion = nn.BCELoss()
   optimizer = optim.Adam(model.parameters(), lr=0.001)
   
   # Обучение
   for epoch in range(10):
       for data, _ in train_loader:
           img = data.view(data.size(0), -1)
           output = model(img)
           loss = criterion(output, img)
   
           optimizer.zero_grad()
           loss.backward()
           optimizer.step()
   
       print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')
   
   # Визуализация
   examples = enumerate(train_loader)
   batch_idx, (example_data, example_targets) = next(examples)
   reconstructed = model(example_data.view(example_data.shape[0], -1)).detach().view(-1, 28, 28)
   
   for i in range(5):
       plt.subplot(2, 5, i+1)
       plt.imshow(example_data[i].squeeze(), cmap='gray')
       plt.title("Original")
       plt.axis('off')
   
       plt.subplot(2, 5, i+6)
       plt.imshow(reconstructed[i].squeeze(), cmap='gray')
       plt.title("Reconstructed")
       plt.axis('off')
   
   plt.show()

Экзаменационный билет №5

Теоретическая часть:

1. Что такое dropout и batch normalization? В чём их основное различие в контексте регуляризации нейронных сетей?
   Ответ: Dropout — это метод регуляризации, при котором случайные нейроны отключаются во время обучения, что снижает зависимость между ними и уменьшает переобучение. Batch normalization нормализует выходы слоёв по батчам, ускоряя обучение и улучшая стабильность сети. Основное различие заключается в том, что dropout действует как регуляризатор, тогда как batch normalization влияет на динамику обучения и не является строгим методом регуляризации, хотя может частично её обеспечивать.

2. Объясните, как работает механизм self-attention в Transformer. Как вычисляются Q, K и V?
   Ответ: Self-attention позволяет модели учитывать взаимосвязи между элементами последовательности. Для этого входные векторы проецируются в три пространства: Query (Q), Key (K) и Value (V) с помощью обучаемых матриц весов. Затем вычисляется матрица внимания через скалярные произведения Q и K, которые масштабируются и пропускаются через softmax для получения весов. Эти веса применяются к V, чтобы получить выход внимания.

Практическая часть:

3. Реализуйте простой Transformer Encoder блок с использованием PyTorch. Используйте nn.MultiheadAttention и реализуйте feed-forward сеть. Протестируйте его на случайной последовательности тензоров.
   Ответ:

   import torch
   import torch.nn as nn
   
   class TransformerEncoderBlock(nn.Module):
       def __init__(self, embed_dim=64, num_heads=4, ff_dim=256, dropout_rate=0.1):
           super(TransformerEncoderBlock, self).__init__()
           self.attention = nn.MultiheadAttention(embed_dim, num_heads)
           self.norm1 = nn.LayerNorm(embed_dim)
           self.dropout1 = nn.Dropout(dropout_rate)
   
           self.ffn = nn.Sequential(
               nn.Linear(embed_dim, ff_dim),
               nn.ReLU(),
               nn.Linear(ff_dim, embed_dim)
           )
           self.norm2 = nn.LayerNorm(embed_dim)
           self.dropout2 = nn.Dropout(dropout_rate)
   
       def forward(self, x):
           # Multi-head attention
           attn_output, _ = self.attention(x, x, x)
           x = x + self.dropout1(attn_output)
           x = self.norm1(x)
   
           # Feed-forward network
           ffn_output = self.ffn(x)
           x = x + self.dropout2(ffn_output)
           x = self.norm2(x)
   
           return x
   
   # Тестирование
   seq_len = 10
   embed_dim = 64
   batch_size = 32
   
   # Случайная последовательность тензоров
   x = torch.randn(seq_len, batch_size, embed_dim)
   
   # Инициализация и применение блока
   block = TransformerEncoderBlock()
   output = block(x)
   
   print("Входной тензор:", x.shape)
   print("Выходной тензор:", output.shape)

Экзаменационный билет №6

Теоретическая часть:

1. Что такое overfitting и какие методы борьбы с ним вы знаете?
   Ответ: Overfitting — это явление, при котором модель слишком точно подстраивается под тренировочные данные и теряет способность обобщать. Методы борьбы: регуляризация (L1/L2), dropout, batch normalization, data augmentation, early stopping, упрощение модели, увеличение размера датасета.

2. Опишите основные компоненты архитектуры VAE и как она отличается от GAN.
   Ответ: VAE состоит из encoder, который кодирует вход в скрытое пространство, и decoder, который его восстанавливает. Обучение происходит на минимизацию reconstruction loss и KL-дивергенции между апостериорным и априорным распределением. В отличие от GAN, VAE не использует противостояние между генератором и дискриминатором, а обучается напрямую восстанавливать данные.

Практическая часть:

3. Реализуйте простой Variational Autoencoder (VAE) для работы с MNIST на PyTorch.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.optim as optim
   from torchvision import datasets, transforms
   
   class VAE(nn.Module):
       def __init__(self, latent_dim=20):
           super(VAE, self).__init__()
           self.encoder = nn.Sequential(
               nn.Linear(28*28, 512),
               nn.ReLU()
           )
           self.mu = nn.Linear(512, latent_dim)
           self.logvar = nn.Linear(512, latent_dim)
   
           self.decoder = nn.Sequential(
               nn.Linear(latent_dim, 512),
               nn.ReLU(),
               nn.Linear(512, 28*28),
               nn.Sigmoid()
           )
   
       def reparameterize(self, mu, logvar):
           std = torch.exp(0.5 * logvar)
           eps = torch.randn_like(std)
           return mu + eps * std
   
       def forward(self, x):
           h = self.encoder(x.view(-1, 28*28))
           mu, logvar = self.mu(h), self.logvar(h)
           z = self.reparameterize(mu, logvar)
           return self.decoder(z), mu, logvar
   
   def loss_function(recon_x, x, mu, logvar):
       BCE = nn.functional.binary_cross_entropy(recon_x, x.view(-1, 28*28), reduction='sum')
       KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
       return BCE + KLD
   
   # Подготовка данных
   transform = transforms.ToTensor()
   train_data = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
   train_loader = torch.utils.data.DataLoader(train_data, batch_size=128, shuffle=True)
   
   # Инициализация модели
   model = VAE()
   optimizer = optim.Adam(model.parameters(), lr=1e-3)
   
   # Обучение
   for epoch in range(10):
       total_loss = 0
       for data, _ in train_loader:
           recon_batch, mu, logvar = model(data)
           loss = loss_function(recon_batch, data, mu, logvar)
   
           optimizer.zero_grad()
           loss.backward()
           optimizer.step()
   
           total_loss += loss.item()
       print(f'Epoch {epoch+1}, Loss: {total_loss / len(train_loader.dataset):.4f}')

Экзаменационный билет №7

Теоретическая часть:

1. Что такое gradient clipping и в каких случаях он применяется?
   Ответ: Gradient clipping — это метод ограничения величины градиентов во время обучения, чтобы избежать проблемы exploding gradients. Применяется в RNN, Transformer и других моделях, где градиенты могут становиться очень большими. Обычно используется при использовании SGD с моментом или Adam.

2. Какие основные компоненты входят в архитектуру YOLO для детекции объектов?
   Ответ: YOLO (You Only Look Once) состоит из backbone-сети для извлечения признаков, neck-части (например, FPN), улучшающей представление признаков на разных уровнях, и head-части, которая предсказывает bounding boxes и классы. Также используется grid-based подход, где изображение делится на ячейки, каждая из которых предсказывает свои объекты.

Практическая часть:

3. Реализуйте простую функцию вычисления IoU (Intersection over Union) между двумя bounding box'ами. Напишите её на Python и протестируйте на примерах.
   Ответ:

   import torch
   
   def iou(box1, box2):
       # box1, box2: [x_min, y_min, x_max, y_max]
       x1_max = max(box1[0], box2[0])
       y1_max = max(box1[1], box2[1])
       x2_min = min(box1[2], box2[2])
       y2_min = min(box1[3], box2[3])
   
       inter_area = max(0, x2_min - x1_max + 1) * max(0, y2_min - y1_max + 1)
       
       area1 = (box1[2] - box1[0] + 1) * (box1[3] - box1[1] + 1)
       area2 = (box2[2] - box2[0] + 1) * (box2[3] - box2[1] + 1)
   
       union_area = area1 + area2 - inter_area
       return inter_area / union_area
   
   # Тестирование
   box_a = [0, 0, 2, 2]
   box_b = [1, 1, 3, 3]
   print(f'IoU между {box_a} и {box_b}: {iou(box_a, box_b):.4f}')  # ~0.1429

Экзаменационный билет №8

Теоретическая часть:

1. В чём разница между обучением с учителем (supervised learning) и без учителя (unsupervised learning)? Приведите примеры задач.
   Ответ: Supervised learning использует размеченные данные (вход + целевой выход), например, классификация или регрессия. Unsupervised learning работает с неразмеченными данными, например, кластеризация (K-Means) или снижение размерности (PCA).

2. Что такое self-supervised learning и почему он становится популярным в NLP и CV?
   Ответ: Self-supervised learning — это метод, где supervisory сигнал создаётся из самих данных. Например, маскировка слов (BERT) или предсказание поворота изображения. Он популярен, потому что позволяет эффективно использовать большие объёмы неразмеченных данных и формировать качественные представления без ручной разметки.

Практическая часть:

3. Реализуйте функцию masked language modeling (MLM) для случайного маскирования токенов в последовательности. Используйте PyTorch.
   Ответ:

   import torch
   import torch.nn as nn
   
   class MLMHead(nn.Module):
       def __init__(self, hidden_size, vocab_size):
           super(MLMHead, self).__init__()
           self.fc = nn.Linear(hidden_size, vocab_size)
   
       def forward(self, x):
           return self.fc(x)
   
   def mask_tokens(input_ids, tokenizer, mlm_probability=0.15):
       labels = input_ids.clone()
       probability_matrix = torch.rand(input_ids.shape)
       special_tokens_mask = [tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in input_ids.tolist()]
       probability_matrix.masked_fill_(torch.tensor(special_tokens_mask, dtype=torch.bool), value=0.0)
       masked_indices = probability_matrix < mlm_probability
       labels[~masked_indices] = -100  # Ignore index in loss
       indices_replaced = torch.bernoulli(torch.full(input_ids.shape, 0.8)).bool() & masked_indices
       input_ids[indices_replaced] = tokenizer.convert_tokens_to_ids(tokenizer.mask_token)
       return input_ids, labels
   
   # Тестирование
   from transformers import BertTokenizer
   tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
   text = "Hello, my dog is cute."
   tokenized = tokenizer(text, return_tensors='pt', padding=True, truncation=True)
   input_ids = tokenized['input_ids']
   masked_input, labels = mask_tokens(input_ids, tokenizer)
   print("Original IDs:", input_ids)
   print("Masked IDs:", masked_input)
   print("Labels:", labels)

Экзаменационный билет №9

Теоретическая часть:

1. Что такое few-shot learning и в каких задачах он применяется?
   Ответ: Few-shot learning — это подход, при котором модель обучается распознавать новые классы по очень малому числу примеров (от 1 до нескольких). Применяется в задачах, где сбор размеченных данных затруднён, например, в медицине, редких событиях или персонализированных системах.

2. Какие метрики используются для оценки качества генеративных моделей?
   Ответ: Для оценки качества генерации изображений применяются Inception Score (IS), Frechet Inception Distance (FID), Precision and Recall. Для текста — BLEU, ROUGE, METEOR, BERTScore. Эти метрики оценивают как качество, так и разнообразие сгенерированных образцов.

Практическая часть:

3. Реализуйте обучение простой GAN для генерации изображений MNIST на PyTorch. Добавьте логику сохранения лучших результатов.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.optim as optim
   from torchvision import datasets, transforms
   from torch.utils.data import DataLoader
   import os
   
   # Генератор
   class Generator(nn.Module):
       def __init__(self):
           super().__init__()
           self.gen = nn.Sequential(
               nn.Linear(100, 256),
               nn.ReLU(),
               nn.Linear(256, 28*28),
               nn.Tanh()
           )
   
       def forward(self, x): return self.gen(x)
   
   # Дискриминатор
   class Discriminator(nn.Module):
       def __init__(self):
           super().__init__()
           self.disc = nn.Sequential(
               nn.Linear(28*28, 256),
               nn.LeakyReLU(0.2),
               nn.Linear(256, 1),
               nn.Sigmoid()
           )
   
       def forward(self, x): return self.disc(x)
   
   # Данные
   transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
   train_loader = DataLoader(datasets.MNIST('.', transform=transform, download=True), batch_size=128, shuffle=True)
   
   # Модели
   G = Generator()
   D = Discriminator()
   opt_G = optim.Adam(G.parameters(), lr=0.0002)
   opt_D = optim.Adam(D.parameters(), lr=0.0002)
   criterion = nn.BCELoss()
   
   # Обучение
   os.makedirs('models', exist_ok=True)
   best_fid = float('inf')
   
   for epoch in range(20):
       for real, _ in train_loader:
           real = real.view(-1, 28*28)
           batch_size = real.shape[0]
           real_labels = torch.ones(batch_size, 1)
           fake_labels = torch.zeros(batch_size, 1)
   
           # D: реальные
           opt_D.zero_grad()
           loss_real = criterion(D(real), real_labels)
           loss_real.backward()
   
           # D: фейковые
           z = torch.randn(batch_size, 100)
           fake = G(z).detach()
           loss_fake = criterion(D(fake), fake_labels)
           loss_fake.backward()
           opt_D.step()
   
           # G
           opt_G.zero_grad()
           fake = G(z)
           loss_g = criterion(D(fake), real_labels)
           loss_g.backward()
           opt_G.step()
   
       print(f'Epoch {epoch+1}, Loss D: {loss_real.item()+loss_fake.item():.4f}, Loss G: {loss_g.item():.4f}')
       
       # Сохранение модели
       fid_score = np.random.rand()  # Здесь должна быть реальная метрика, например, FID
       if fid_score < best_fid:
           best_fid = fid_score
           torch.save(G.state_dict(), 'models/gan_generator.pth')

Экзаменационный билет №10

Теоретическая часть:

1. Что такое MLOps и как он связан с жизненным циклом ML-моделей?
   Ответ: MLOps — это набор практик DevOps, адаптированных под машинное обучение. Он охватывает все этапы жизненного цикла модели: разработка, тестирование, развёртывание, мониторинг, версионирование, CI/CD, A/B-тестирование. Цель — автоматизация и стандартизация работы с ML-системами в production.

2. Какие современные архитектуры используются в компьютерном зрении и почему они эффективны?
   Ответ: Современные архитектуры: Vision Transformers (ViT), ConvNeXt, EfficientNet, Swin Transformer. ViT использует механизмы внимания и показывает высокую точность. ConvNeXt сочетает преимущества CNN и Transformer. EfficientNet балансирует точность и производительность. Swin Transformer оптимизирован для длинных последовательностей изображений.

Практическая часть:

3. Реализуйте простой пайплайн MLOps: сохранение модели, загрузка, инференс и сериализация в ONNX.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.onnx
   
   # Простая модель
   class Net(nn.Module):
       def __init__(self):
           super().__init__()
           self.lin = nn.Linear(10, 2)
   
       def forward(self, x): return self.lin(x)
   
   # Обучение
   model = Net()
   torch.save(model.state_dict(), "models/simple_model.pth")
   
   # Загрузка
   model_loaded = Net()
   model_loaded.load_state_dict(torch.load("models/simple_model.pth"))
   model_loaded.eval()
   
   # Инференс
   x = torch.randn(1, 10)
   with torch.no_grad():
       out = model_loaded(x)
   print("Предсказание:", out)
   
   # Экспорт в ONNX
   dummy_input = torch.randn(1, 10)
   torch.onnx.export(model_loaded, dummy_input, "models/simple_model.onnx", export_params=True,
                     opset_version=10, do_constant_folding=True,
                     input_names=['input'], output_names=['output'])
   print("Модель экспортирована в ONNX")

Экзаменационный билет №11

Теоретическая часть:

1. Что такое distributed training и какие подходы к нему существуют в PyTorch?
   Ответ: Distributed training — это обучение модели на нескольких GPU или узлах для ускорения процесса. В PyTorch реализовано несколько подходов: DataParallel (простой, но менее эффективный), DistributedDataParallel (лучшая производительность), а также использование torch.distributed для низкоуровневого контроля.

2. Как работает механизм scheduled sampling в RNN и почему он полезен?
   Ответ: Scheduled sampling — это метод обучения RNN, при котором модель постепенно переходит от использования ground truth как входа к использованию собственных предсказаний. Это помогает снизить разницу между обучением и инференсом (exposure bias) и улучшает стабильность генерации.

Практическая часть:

3. Реализуйте простую RNN-модель с использованием scheduled sampling на PyTorch для задачи генерации последовательностей.
   Ответ:

   import torch
   import torch.nn as nn
   
   class SeqModel(nn.Module):
       def __init__(self, input_size, hidden_size, output_size):
           super().__init__()
           self.rnn = nn.GRU(input_size, hidden_size, batch_first=True)
           self.fc = nn.Linear(hidden_size, output_size)
   
       def forward(self, x, teacher_forcing_ratio=0.5, targets=None):
           batch_size = x.size(0)
           seq_len = x.size(1)
           hidden = torch.zeros(1, batch_size, self.rnn.hidden_size)
           outputs = []
           inp = x[:, 0, :]
   
           for t in range(seq_len):
               out, hidden = self.rnn(inp.unsqueeze(1), hidden)
               out = self.fc(out.squeeze(1))
               outputs.append(out.unsqueeze(1))
   
               if targets is not None and torch.rand(1).item() < teacher_forcing_ratio:
                   inp = targets[:, t, :]
               else:
                   inp = torch.softmax(out, dim=-1)
   
           return torch.cat(outputs, dim=1)
   
   # Тестирование
   model = SeqModel(input_size=10, hidden_size=32, output_size=10)
   x = torch.randn(8, 5, 10)
   targets = torch.randint(0, 10, (8, 5)).long()
   outputs = model(x, targets=targets)
   print("Выходной тензор:", outputs.shape)

Экзаменационный билет №12

Теоретическая часть:

1. Опишите основные отличия между GAN и VAE как моделей генерации данных.
   Ответ: GAN использует противостояние между генератором и дискриминатором, что позволяет создавать более реалистичные данные, но обучение может быть нестабильным. VAE основан на вероятностном моделировании и явно кодирует данные в скрытое пространство, что делает его более стабильным, но качество генерации может быть ниже.

2. Что такое knowledge distillation и как она используется в практике?
   Ответ: Knowledge distillation — это метод переноса знаний от большой модели (teacher) к маленькой (student). Маленькая модель обучается воспроизводить выходы большой, что позволяет создавать компактные и быстрые модели, сохраняя высокую точность.

Практическая часть:

3. Реализуйте простой пайплайн knowledge distillation, где маленькая CNN-модель обучается по выходам большой CNN на наборе CIFAR-10.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.optim as optim
   from torchvision import datasets, transforms
   from torch.utils.data import DataLoader
   
   # Учительская модель
   class Teacher(nn.Module):
       def __init__(self):
           super().__init__()
           self.net = nn.Sequential(
               nn.Conv2d(3, 128, 3), nn.ReLU(),
               nn.MaxPool2d(2),
               nn.Conv2d(128, 256, 3), nn.ReLU(),
               nn.AdaptiveAvgPool2d((1,1)),
               nn.Flatten(),
               nn.Linear(256, 10)
           )
   
       def forward(self, x): return self.net(x)
   
   # Студенческая модель
   class Student(nn.Module):
       def __init__(self):
           super().__init__()
           self.net = nn.Sequential(
               nn.Linear(3*32*32, 128),
               nn.ReLU(),
               nn.Linear(128, 10)
           )
   
       def forward(self, x): return self.net(x.view(-1, 3*32*32))
   
   # Подготовка данных
   transform = transforms.ToTensor()
   train_data = datasets.CIFAR10('.', transform=transform, download=True)
   train_loader = DataLoader(train_data, batch_size=128, shuffle=True)
   
   # Инициализация
   teacher = Teacher().eval()
   student = Student()
   optimizer = optim.Adam(student.parameters(), lr=0.001)
   
   # Обучение с дистилляцией
   for epoch in range(5):
       for x, y in train_loader:
           with torch.no_grad():
               soft_targets = teacher(x).detach()
   
           student_preds = student(x)
           loss = nn.KLDivLoss(reduction='batchmean')(F.log_softmax(student_preds, dim=1),
                                                       F.softmax(soft_targets, dim=1))
           optimizer.zero_grad()
           loss.backward()
           optimizer.step()
   
       print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')

Экзаменационный билет №13

Теоретическая часть:

1. Что такое quantization и какие виды quantization используются в глубоком обучении?
   Ответ: Quantization — это снижение точности представления весов модели (например, float32 → int8) для уменьшения размера и увеличения скорости вывода. Виды: post-training quantization, quantization-aware training, dynamic quantization. Применяется в edge устройствах и мобильных приложениях.

2. Какие метрики используются для оценки качества NLP-моделей и в чём их особенность?
   Ответ: BLEU, ROUGE, METEOR, CIDEr, perplexity, BERTScore. Эти метрики сравнивают сгенерированный текст с эталонами, оценивая совпадение n-грамм, семантику и связность. BERTScore использует contextual embeddings для повышения корреляции с человеческой оценкой.

Практическая часть:

3. Реализуйте простую модель seq2seq с attention для перевода коротких фраз.
   Ответ:

   import torch
   import torch.nn as nn
   
   class Encoder(nn.Module):
       def __init__(self, input_size, hidden_size):
           super().__init__()
           self.embedding = nn.Embedding(input_size, hidden_size)
           self.gru = nn.GRU(hidden_size, hidden_size)
   
       def forward(self, x):
           embedded = self.embedding(x)
           outputs, hidden = self.gru(embedded)
           return outputs, hidden
   
   class Decoder(nn.Module):
       def __init__(self, hidden_size, output_size):
           super().__init__()
           self.embedding = nn.Embedding(output_size, hidden_size)
           self.attn = nn.Linear(hidden_size * 2, 1)
           self.gru = nn.GRU(hidden_size, hidden_size)
           self.out = nn.Linear(hidden_size, output_size)
   
       def forward(self, x, encoder_outputs):
           embedded = self.embedding(x.unsqueeze(0))
           attn_weights = torch.softmax(self.attn(torch.cat([embedded.repeat(encoder_outputs.size(0),1,1), encoder_outputs], dim=2)), dim=0)
           context = torch.sum(attn_weights * encoder_outputs, dim=0)
           output, hidden = self.gru(context.unsqueeze(0))
           return self.out(output.squeeze(0)), hidden
   
   # Тестирование
   encoder = Encoder(input_size=1000, hidden_size=256)
   decoder = Decoder(hidden_size=256, output_size=1000)
   
   input_seq = torch.randint(0, 1000, (10, 1))  # длина последовательности = 10, batch_size = 1
   encoder_out, hidden = encoder(input_seq)
   
   output_tokens = []
   decoder_input = torch.tensor(0)  # SOS token
   for _ in range(10):
       decoder_output, hidden = decoder(decoder_input, encoder_out)
       decoder_input = decoder_output.argmax()
       output_tokens.append(decoder_input.item())
   
   print("Сгенерированные токены:", output_tokens)

Экзаменационный билет №14

Теоретическая часть:

1. Что такое curriculum learning и в каких случаях его стоит применять?
   Ответ: Curriculum learning — это стратегия обучения, при которой данные подаются модели в порядке возрастания сложности. Позволяет улучшить сходимость и обобщающую способность, особенно когда данные имеют иерархическую структуру или модель чувствительна к начальным условиям.

2. Какие современные подходы к оптимизации графа вычислений в DL вы знаете?
   Ответ: Operator fusion, layout optimization, kernel autotuning, constant folding, memory planning. Эти методы применяются в бэкендах (ONNX, TensorRT) для ускорения вывода, снижения latency и улучшения использования ресурсов GPU/CPU.

Практическая часть:

3. Реализуйте экспорт модели из PyTorch в ONNX и выполните inference с помощью onnxruntime.
   Ответ:

   import torch
   import torch.nn as nn
   import torch.onnx
   import onnx
   import onnxruntime as ort
   
   # Простая модель
   class Net(nn.Module):
       def __init__(self):
           super().__init__()
           self.lin = nn.Linear(10, 2)
   
       def forward(self, x): return self.lin(x)
   
   # Экспорт в ONNX
   model = Net()
   dummy_input = torch.randn(1, 10)
   torch.onnx.export(model, dummy_input, "models/simple_model.onnx", export_params=True,
                     opset_version=10, do_constant_folding=True,
                     input_names=['input'], output_names=['output'])
   
   # Загрузка и инференс через onnxruntime
   ort_session = ort.InferenceSession("models/simple_model.onnx")
   outputs = ort_session.run(None, {'input': dummy_input.numpy()})
   print("Результат инференса:", outputs)

Экзаменационный билет №15

Теоретическая часть:

1. Что такое self-supervised learning и какие задачи он использует?
   Ответ: Self-supervised learning — это подход, при котором supervisory сигнал формируется из самих данных без явной разметки. Примеры задач: masked language modeling (BERT), rotation prediction, jigsaw puzzle, contrastive learning (SimCLR, MoCo).

2. Что такое NAS (Neural Architecture Search) и зачем он нужен?
   Ответ: NAS — это автоматический поиск архитектуры нейронной сети с помощью алгоритмов оптимизации. Цель — найти наиболее эффективную и точную архитектуру для конкретной задачи, минимизируя участие человека в дизайне модели.

Практическая часть:

3. Реализуйте простую NAS-систему с использованием случайного поиска архитектур.
   Ответ:

   import random
   import torch
   import torch.nn as nn
   import torch.optim as optim
   
   def random_model():
       layers = []
       for _ in range(random.randint(1, 4)):
           layers.append(nn.Linear(128, 128))
           layers.append(random.choice([nn.ReLU(), nn.Tanh(), nn.Sigmoid()]))
       return nn.Sequential(*layers, nn.Linear(128, 10))
   
   # Простейший NAS
   best_acc = 0
   for i in range(10):
       model = random_model()
       criterion = nn.CrossEntropyLoss()
       optimizer = optim.Adam(model.parameters(), lr=0.001)
   
       # Тестовые данные
       x = torch.randn(100, 128)
       y = torch.randint(0, 10, (100,))
   
       # Обучение
       for epoch in range(3):
           pred = model(x)
           loss = criterion(pred, y)
           optimizer.zero_grad()
           loss.backward()
           optimizer.step()
   
       acc = (pred.argmax(dim=1) == y).float().mean().item()
       print(f"Модель {i+1}, Accuracy: {acc:.4f}")
   
       if acc > best_acc:
           best_acc = acc
           best_model = model
   
   print("Лучшая точность:", best_acc)