PMLDL oral

BERT

Bidirectional Encoder Representations from Transformers

Does changing the activation from sigmoid to ReLU will resolve vanishing gradient?

Switching the activation function from sigmoid to ReLU can help address the vanishing gradient problem. The sigmoid function compress its output values between 0 and 1, leading to very small derivatives for large values of input data. This can cause gradients to vanish in deep networks. On the other hand, the ReLU function has a constant derivative of 1 for positive input values, which reduces the risk of them vanishing.

Mini-batch Gradient Descent

● optimization method ● updates the model's weights on small groups of samples known as mini-batches.

What are the core idea(s) in Deep Learning?

● to train deep features hierarchies - At the lowest level, learn very simple patterns or features (like borders in an image). deeper, it learns to combine these simple patterns to recognize more complex features (objects). Important for model to understand complex data in detailed way ● to have some form of regularization - Regularization methods like dropout, L1/L2 regularization, and data augmentation introduce some form of limitation or modification to the learning process to avoid overfitting. ● to ensure good generalization - Generalization refers to the model's ability to perform well on new data, not just the known data. It's the ultimate goal of any machine learning model - to be able to make accurate predictions or decisions in real-world, novel situations. If a model doesn't generalize well, its usefulness is limited.

ELU

●(Exponential Linear Unit) ● For x>0, ELU(x)=x ● For x≤0, ELU(x)=α(ex−1), where α - constant, usialy equal 1. ● Like ReLU, ELU outputs the input directly if it's positive. But for negative inputs, instead of zero, it outputs a small negative number based on a formula.

Variable-Length Input Sequences

These occur when the data fed into a model varies in length. For example, in natural language processing tasks, each sentence or document might have a different number of words.

What are the stages of the Machine Learning lifecycle?

● Planning ● Data Preparation ● Model Engineering ● Model Evaluation ● Model Deployment ● Monitoring and Maintenance

List the ways you can produce a sparse model.

● Pruning: This process involves removing some weights from the model (usually those with low value or little impact on the output of the model). Pruning can be done during or after training. ● L1 Regularization: Applying L1 regularization penalizes the model for having large weights and encourages sparsity of weights. ● Using Sparse Data Structures: Some algorithms and data structures naturally support sparsity, like sparse matrices. ● Training with Sparsity (Sparse Training): This is a method where sparsity is introduced during the training process, typically by applying certain constraints or techniques.

MLP

(Basic Multilayer Perceptron) is a type of artificial neural network composed of three key types of layers: an input layer, one or more hidden layers, and an output layer. The neurons in these layers are typically fully connected. MLPs are used for tasks like classification, regression, and even more complex tasks like speech or image recognition.

RNN

(Recurrent Neural Networks) This type of neural network is particularly suited for sequential data like text or time series. They can take into account the previous state of the network when processing new data.

When would you want to add a batch normalization layer?

A batch normalization layer is typically added after layers of the network but before the activation function. It is especially useful in deep networks, where gradient propagation problems can slow down training or lead to instability.

Error Gradients

Error gradients in the context of neural networks are vectors (sets of numbers) that indicate how the weights of the network should be adjusted to decrease the error. Error gradients help us understand in which direction we need to adjust the weights to decrease the error.

GAN

Generator and discriminator

In PyTorch, why is it necessary to call optimizer.zero_grad() during each step of training?

In PyTorch, optimizer.zero_grad() is used to reset gradients before performing backpropagation at each training step. This is necessary for the following reasons: ● Gradient Accumulation: In PyTorch, gradients accumulate by default, meaning that each time .backward() is called, gradients for each parameter are summed up. ● If the gradients are not reset, the parameter updates will be based on accumulated gradients from past steps, which can significantly skew the training process and lead to incorrect results. ● Resetting the gradients at each step ensures the developer has full control over the training process and guarantees that each parameter update is based only on the data from the current step.

Write down the formulas of the output shapes of convolution. Let a convolution layer be defined as conv_layer = nn.Conv2d(3,16,5). What will be the shape of a tensor with initial shape (1, 3, 256, 256) after applying conv_layer?

Output size = (Input size - Filter size + 2 * Padding) / stride + 1 nn.Conv2d(3, 16, 5) ● 3 входных канала, ● 16 выходных каналов, ● Размер фильтра (ядра) 5x5, ● По умолчанию padding (заполнение) равен 0 и stride (шаг) равен 1.

Write down the formula of softmax. Why the values after softmax may be equal to zero?

Softmax(z_i) = e^(z_i) / (sum ^K _j = 1 e^(z_j) z_i​ is the i-th element of the vector z, K is the number of elements in the vector z, e is the base of the natural logarithm. Due to computer arithmetic limitations, very small values can be rounded down to zero. This is happend hen there is a large difference between elements in the vector z, leading to exponentially small values in the denominator of softmax.

Sparsity and Sparse Models

Sparsity in machine learning refers to models where most of the weights or parameters are zero or close to zero. Sparse models are often more efficient in terms of computation and data storage.

Is it a good idea to stop Mini-batch Gradient Descent immediately when the validation error goes up?

Stopping Mini-batch Gradient Descent immediately as the validation error starts to increase might not always be a good idea. Here's why: ● Noisy Data: Validation error could temporarily increase due to noise in the data or feature of a specific mini-batch. This doesn't necessarily mean that the model has stopped learning effectively. ● Local Maxima and Minima: The model might hit a local error minimum and get worse temporarily before finding a more optimal solution. ● Early Stopping: While early stopping is a useful technique to prevent overfitting, it's important to have some delay or "patience" before stopping, to ensure that the increase in error is not just a temporary fluctuation.

What is the purpose of torch.no_grad()? Provide an example where it may be used.

The torch.no_grad() function in PyTorch is used to temporarily disable gradient computation. In PyTorch, gradients are automatically calculated and stored during training for backpropagation. However, in certain scenarios, such as model evaluation or using the model for inference, gradient computation is not necessary and can lead to unnecessary computational resource usage. For example, torch.no_grad() is used during model evaluation. Since weight updates of the model are not required during evaluation, gradient computation is disabled to save resources and speed up the inference process.

What is vanishing gradient?

The vanishing gradient problem occurs in deep neural networks when the error gradients propagated back to the earlier layers become very small. This means that the weights in the initial layers of the network update very slowly, if at all, making it difficult or even impossible to effectively train the network.

Mini-Batches

These are small subsets of the training data used for updating the model's weights at each training step. The size of these batches (often referred to as "batch size") can vary, typically being numbers like 32, 64, 128, etc. The choice of batch size can impact the speed and quality of training.

Autoencoders

They consist of two parts: an encoder, which compresses the input data into a more compact representation, and a decoder, which tries to reconstruct the original data from the compressed representation.

Variable-Length Output Sequences

This is when the model needs to generate outputs of varying lengths. For example, in text translation, the length of the translated sentence may differ from that of the original.

How do you tie weights in a stacked autoencoder?

Tying weights in a stacked autoencoder means that the weights of the decoder are set as the mirror image of the encoder's weights. This implies that instead of learning separate weights for the encoder and decoder, the weights of the decoder are set as the transpose of the encoder's weights.

What happens when calling model.eval()? Name at least 2 layers affected by it.

When calling model.eval() in PyTorch, the behavior of certain layers changes to adapt them for the inference mode. This is particularly relevant for the following types of layers: ● Dropout Layers: In eval() mode, the dropout functionality is completely disabled, ensuring all neurons are active and participate in making predictions. ● Batch Normalization Layers: In eval() mode, they use global statistics collection during training, making the output more stable and predictable. ● Normalization Layers(Layer Normalization, Instance Normalization): SAME

Transformers

are a deep learning architecture designed for processing sequential data, especially in the field of natural language processing (NLP). They differ from previous approaches like Recurrent Neural Networks (RNNs) and LSTMs in that they do not require sequential processing of data.

Sampled Softmax

is a technique used in neural network training when dealing with very large vocabularies, for instance, in natural language processing (NLP) tasks. In the traditional softmax, a probability is computed for every word in the vocabulary for each example in the training set, which can be computationally expensive with large vocabularies.

Regularization

is a technique used to prevent overfitting, where a model learns the training data too well, including its noise and outliers, and fails to generalize to new data

MLOps (Machine Learning Operations)

is not a person or a specific role, but rather a concept and a set of practices that combine machine learning, software development, and operational activities. This concept is aimed at improving and automating the processes of development and deployment of machine learning models.

Smoother gradients

refers to how the function behaves and changes in response to different input values, especially around zero.

Generalization

refers to the model's ability to perform well on new, unseen data, not just the data on which it was trained.

Stochastic Gradient Descent

updates the model's weights on a single example at a time

Batch Gradient Descent

updates the model's weights on the entire dataset at once

ReLU

● (Rectified Linear Unit) ● ReLU(x)=max(0,x) ● If the input is positive, ReLU just outputs that number. If the input is negative, it outputs zero.

Language Model

● A language model used to predict the next word or character in a text sequence. The main task of such a model is to understand which words (or characters) commonly occur together in a language. ● Applications: - Machine Translation: For translating text from one language to another. - Text Generation: Creating new text that mimics the style and context of the source text. - Speech Recognition: Converting spoken audio into text. - Spelling and Grammar Check: For detecting and correcting errors in text. ● How It Works: -Language models evaluate the likelihood of a sequence of words and can be based on statistical methods or neural networks. - Modern approaches often use deep learning algorithms, such as transformers.

Describe BERT pre-training objective

● BERT, introduced by Google, is a natural language processing model. The main goal of BERT's pre-training is to enable the model to effectively understand language context and nuances. This is achieved through two primary tasks: ● Masked Language Model (MLM): During training, some words in a sentence are randomly replaced with a special [MASK] token. The model's task is to predict the original word based on the context. This allows BERT to learn the context and meaning of words in various sentence positions. ● Next Sentence Prediction (NSP): BERT is also trained to predict whether one sentence logically follows another. During training, the model is presented with pairs of sentences and must determine if they sequentially follow each other in the original text.

Differences Between Batch Normalization and Layer Normalization

● Batch Normalization: Normalizes the data across the entire mini-batch, for each feature separately. ● Layer Normalization: Normalizes all the features within a single sample. It is less dependent on the size of the mini-batch and often performs better with recurrent neural networks.

What is the difference between nn.Embedding and nn.EmbeddingBag?

● Both nn.Embedding and nn.EmbeddingBag are layers in PyTorch designed for embedding operations. ● nn.Embedding: used for converting indices into embedding vectors ● EmbeddingBag computes the "sum", "mean", or "max" of embedding vectors ● Aggregation: EmbeddingBag automatically aggregates embedding vectors, while Embedding returns individual vectors. ● Performance: EmbeddingBag can be more efficient in terms of performance and memory, especially when dealing with large sequences, as it avoids the need for additional operations to aggregate vectors after obtaining them.

Teams in DS. Roles

● CDO/CAO ● Business analyst ● Data analyst ● Data scientist - Prove / disprove hypotheses - Information and Data gathering - Data wrangling - Algorithm and ML models - Communication ● PM ● ML engineer ● Data architect ● Data engineer - Build Data Driven Platforms - Operationalize algorithm amd ML model - Data Integration ● Application engineer ● Data journalist ● Visualization Expert - Storytelling - Build Dashboards and other Data visualizations - Provide insight through visual means ● Procces Owner - Project Management - Manage stakeholder expectations - Maintain a Vision - Facilitate

What is beam search and why would you use it?

● Definition: Beam search is a search algorithm commonly used in machine translation and text generation tasks, where the goal is to find the most probable sequence of words. It's a type of greedy algorithm that, at each step, considers several best options (defined by the "beam width" parameter) and chooses the most optimal one among them. ● Why Use It: - Balance Between Efficiency and Quality: Beam search provides a compromise between searching through all possible sequences (which is too resource-intensive) and choosing the single best option at each step (which may not yield the best result). - Improved Generation Quality: It allows for generating more coherent and naturally sounding sequences, as it considers multiple potential continuation options at each step. - Application in Machine Translation and Text Generation: Widely used in machine translation systems and text generation where it's crucial to achieve a high-quality and coherent output.

How is MLOps different from DevOps?

● DevOps: Focused on software development and operational processes. ● MLOps: Concentrated on the lifecycle of machine learning model development and operations. ● DevOps: Less emphasis on data management. ● MLOps: Strong focus on efficient data management and the lifecycle of machine learning models. ● DevOps: Automation of development and operational processes. ● MLOps: Automation of training, deployment, monitoring, and maintenance processes for machine learning models.

What are the main tasks that autoencoders are used for?

● Dimensionality Reduction: Similar to PCA, autoencoders can compress data into a lower-dimensional space. ● Anomaly Detection: Since autoencoders are trained to reconstruct "normal" data, they reconstruct anomalies poorly, which allows for their detection. ● Denoising: Autoencoders can learn to reconstruct clean data from noisy inputs. ● Data Generation: In certain types, like Variational Autoencoders (VAEs), they are used for generating new data similar to what they were trained on. ● Pretraining for Deep Networks: Used for stepwise training of deep networks, especially when there is a lack of labeled data.

Explain the idea behind dropout. How does it work in the inference mode?

● Dropout is a regularization technique used in training neural networks to prevent overfitting. The main idea is to randomly "turn off" (i.e., temporarily exclude from training) a certain percentage of neurons in the network at each training step. ● When using the network for predictions (in inference mode), dropout is usually disabled. This means all neurons participate in making predictions. ● To compensate for the disabling of dropout, weight scaling methods may be used. For example, the weights obtained during training are multiplied by the probability of keeping neurons (1 minus the dropout probability) to balance their influence in inference mode.

Why would you want to use 1D convolutional layers in an RNN?

● Feature Extraction: 1D convolutional layers can be used to preprocess input data for RNNs, extracting key features in sequences, which can improve the learning and performance of RNNs. ● Sequence Length Reduction: 1D convolutional layers can reduce the length of input sequences, which eases the burden on RNNs and can improve handling of long sequences. ● Improving Time Efficiency: Applying convolutions allows RNNs to process data more quickly by reducing sequence length, making the network more time-efficient.

Why is it necessary to restrict high values of weights during regularization?

● Preventing Overfitting: High weights often indicate that the model has adapted too closely to the training data, including noise and outliers, which diminishes its ability to generalize to new data. ● Improving Generalizability: By limiting the weights, we force the model to focus on broader patterns in the data rather than specific features of the training set. ● Model Stability: High weights can lead to instability in the model's output, especially with minor changes in input data. Restricting weights helps make the model more stable and predictable. ● Reducing Output Variability: Smaller weights reduce the risk of significant changes in the model's output due to small fluctuations in input data, which is particularly important in tasks sensitive to input variations.

Why is it necessary to fix a random seed? Why may it be necessary to perform experiments with different seeds?

● Fixing a random seed in machine learning is important for several reasons: - Reproducibility of Results: Fixing the seed ensures that the results of experiments can be reproduced. This is critically important for scientific research and model verification, as it allows other researchers to obtain the same results using the same code and data. - Consistency in Training: When training machine learning models, fixing the seed helps ensure stability in the training process, as the initialization of weights and data splitting remain unchanged with each run. ● Conducting experiments with different seeds is also important for several reasons: - Assessing Model Reliability: Using different seeds allows assessing how reliably the model behaves under different initial conditions. This helps ensure that good model performance is not a fluke or a result of specific initialization. - Identifying Overfitting: Different initial conditions can reveal a model's tendency to overfit, especially if the model's performance varies significantly depending on the seed. - Overall Robustness: Experiments with different seeds help ensure that the model is generally robust and performs well in various scenarios.

Howcan you deal with variable-length input sequences? What about variable-length output sequences?

● For Input Sequences: - Padding: Adding "empty" elements to shorter sequences to make them all the same length. - Masking: Using special masks to tell the model which parts of the data are "empty" and should not be considered during training. ● For Output Sequences: - Attention Mechanisms: Allow the model to focus on different parts of the input data when generating each element of the output sequence. - Sequence-to-Sequence Models (Seq2Seq): Particularly useful when the length of the output data is not known in advance.

GNNs. Definition and Applications

● Graph Neural Networks (GNN) are a type of neural networks designed to work with data represented as graphs. GNNs are unique in their ability to process relationships and interconnections between objects, which is a key element in graph structures. ● Applications: - Social Networks: Analyzing and modeling interactions and connections between users.\ - Recommendation Systems: Predicting user interests based on network relationships and preferences. - Chemoinformatics: Modeling molecular structures and predicting chemical properties. - Traffic and Transportation Networks: Optimizing routes and analyzing traffic patterns. - Natural Language Processing: Used for analyzing semantic and syntactic structures in text.

Graph neural networks. What is Node2vec?

● Graph Neural Networks (GNN) are a type of neural networks designed to work with data represented as graphs. GNNs are unique in their ability to process relationships and interconnections between objects, which is a key element in graph structures. ● Node2vec is an algorithm for generating vector representations (embeddings) of nodes in a graph. Drawing on ideas from word2vec in natural language processing, node2vec leverages the structure of the graph to create numerical representations of nodes that reflect their network neighborhoods and connections. ● Node2vec generates random walks through the graph starting from each node. These walks capture information about the graph's structure and the connections between nodes. It then uses algorithms similar to word2vec (e.g., Skip-Gram) to transform the sequences of nodes obtained from walks into vector representations. ● Applications: - Recommendation Systems: Predicting user preferences based on their connections in social networks. - Node Classification: Categorizing nodes in a graph based on their embeddings. - Social Network Analysis: Studying and visualizing complex network structures - Node Similarity Determination: Calculating the degree of similarity between nodes in a graph.

What happens when all the weights of a convolution layer are initialized with zeros? How does it affect the training?

● Lack of Symmetry Breaking: every neuron in the layer will learn the same features, leading to a loss of diversity in learning. ● Backpropagation Does Not Alter Weights: the weights will remain zero throughout the training process. ● The Network Does Not Learn: no update - no learn ● Loss of Convolutional Layer's Power: cant chose key from data

When would you need to use sampled softmax?

● Large Vocabularies: When you're working with tasks where the vocabulary contains thousands or even millions of words (like in machine translation or language models). ● Limited Computational Resources: If the available resources are limited and computing the full softmax is impractical due to high memory and processing time requirements. ● Faster Training: To speed up the training process, as sampled softmax significantly reduces the number of computations needed.

List all the hyperparameters you can tweak in a basic MLP?

● Number of Hidden Layers: Determines the depth of the network. ● Number of Neurons in Each Layer: Affects the network's learning and generalization capabilities. ● Activation Functions: Determine how signals are transformed between layers (e.g., ReLU, Sigmoid, Tanh). ● Learning Rate: Determines how quickly the model updates its weights. ● Optimization Algorithm: E.g., SGD, Adam, RMSprop. ● Batch Size: The number of training examples used in one training step. ● Number of Epochs: How many times the training set is presented to the model during training. ● Regularization: E.g., L1, L2, or Dropout to prevent overfitting. ● Weight Initialization: Method of initially setting the weights (e.g., random initialization, He or Xavier initialization). ● Momentum: Helps to accelerate SGD in the right direction and reduce oscillations. ● Layer Normalization or Batch Normalization: Used to stabilize and speed up the training process.

What are the advantages of a CNN(Convolutional Neural Networks) over a fully connected DNN(Deep Neural Networks) for image classification?

● Parameter Efficiency: CNNs require significantly fewer parameters compared to fully connected DNNs. This is achieved through the use of convolutional filters applied to different areas of the image. ● Spatial Hierarchy Consideration: CNNs effectively take into account spatial relationships between pixels, detecting local features at early layers and more complex patterns at deeper layers. ● Reduced Overfitting: The smaller number of parameters and the ability of CNNs to identify key features reduce the risk of overfitting compared to fully connected networks. ● Transferability of Trained Models: CNN models are trained to identify universal features (like edges, corners), making them well transferable to different image classification tasks. ● Efficient Processing of Large Images: CNNs can efficiently handle large images, whereas fully connected networks quickly become inefficient due to the massive number of parameters.

What is the purpose of data augmentation? How can it help in training a network?

● Purpose of Data Augmentation - Data augmentation is the process of creating new training data by making modifications to existing data. This is especially common in computer vision tasks, where images can be altered in various ways, such as by rotating, scaling, cropping, or changing color. ● How Data Augmentation Helps in Training Networks - Increasing Dataset Size: Augmentation allows for an increase in the amount of training data, which is particularly beneficial when the original dataset is limited. - Reducing Overfitting: The diversity in the training data helps prevent overfitting, as the network learns not to memorize exact samples but to generalize from a broader set of examples. - Improving Generalizability: The network becomes more robust to minor variations in input data, improving its ability to classify or recognize in real-world conditions. - Mimicking Real-world Scenarios: Augmentation can help the network train on examples that are closer to real-world application conditions, such as under different lighting conditions or angles for images.

If your GPU runs out of memory while training a CNN, what are five things you could try to solve the problem?

● Reduce Batch Size: Decreasing the number of samples processed at one time will reduce memory usage since each sample requires a certain amount of memory to store intermediate data during training. ● Reduce Layer Dimensions: Lowering the number of filters in convolutional layers or the number of neurons in fully connected layers will reduce the number of weights and memory requirements. ● Use Lighter Network Architectures: Opting for simpler architectures with fewer layers or parameters will also help in reducing memory consumption. ● Apply Model Compression Techniques: Techniques like weight quantization or sparsity (applying sparsity) can reduce the size of the model without significant performance loss. ● Use Gradient Accumulation: This is a method where gradients are summed over several mini-batches before updating the weights, allowing for smaller batch sizes without loss in gradient quality. ● Use gc.collect(): In Python, you can invoke the garbage collector gc.collect() to free up unused memory. This can be helpful if there are unreferenced Python objects in your workflow that can be cleared. ● torch.cuda.empty_cache() in PyTorch: If you're using PyTorch, you can release unused cached memory on the GPU using torch.cuda.empty_cache(). This can free up some amount of GPU memory that was previously reserved but is currently not in use.

Name advantages of the ELU activation function over the ReLU

● Reduces Dying ReLU Problem: ELU avoids the issue of neurons becoming inactive, a common problem with ReLU. ● Smoother Gradients: Offers smoother gradient transition for negative values, support in succes training. ● Improves Generalization: Can lead to better model performance on unseen data due to its non-zero gradients for negative inputs. ● Zero-Centering Capability: Pushes the mean of activations closer to zero, which can speed up learning. ● Potentially Faster Convergence: Some networks using ELU may learn faster compared to those using ReLU. ● Double Saturation: Saturates in both positive and negative directions, potentially leading to more stable learning.

What is the point of doing tie weights in a stacked autoencoder?

● Reducing the Number of Parameters: This cuts down the number of trainable parameters, making the model more compact and reducing the risk of overfitting. ● Improving Training Efficiency: With fewer parameters to train, the training becomes more efficient and often faster. ● Symmetrical Architecture: Tying weights creates symmetry between the encoder and decoder, which intuitively aligns with the idea of reconstructing the input data. ● Reducing the Risk of Overfitting: With fewer parameters to train, the risk of overfitting is reduced, as the model becomes less prone to memorizing the training data and better at generalizing to new data.

Mention six ways to prevent overfitting in a Neural Network?

● Regularization: This includes techniques like L1 and L2, which add a penalty to the loss function to limit the magnitude of the weights. It helps prevent the model from fitting too closely to the training data. ● Dropout: A technique where neurons are randomly "turned off" during training, helping to prevent over-reliance on specific pathways in the network and promoting more distributed learning. ● Data Augmentation: Altering or adding new data to the training set to increase its size and diversity. This helps the model learn from a wider range of examples. ● Early Stopping: Halting the training when the error on the validation data set begins to increase prevents the model from overfitting. ● Reducing Model Complexity: Using a simpler model with fewer parameters or layers can help reduce the risk of overfitting. ● Batch Normalization: Normalizing the inputs of each layer across mini-batches, which helps speed up training and increase its stability.

Give 5 reasons why we need MLOps?

● Standardization and Automation of Processes: MLOps implements standards and automates the deployment and monitoring processes of machine learning models, simplifying their integration into production systems. ● Improved Quality and Reliability of Models: Continuous monitoring and testing of models within MLOps enhance their quality and reliability, ensuring stable operation in real-world conditions. ● Faster Iteration and Innovation Cycle: MLOps allows for quicker changes and improvements to models, accelerating the cycle of innovation and optimization. ● Collaboration and Teamwork: Facilitates interaction between data scientists, engineers, and analysts, promoting better collaboration and more efficient team performance. ● Compliance with Regulatory Requirements: MLOps helps adhere to regulatory and legislative requirements, especially concerning data management, security, and privacy.

Explain the approach behind BLEU score. What does it mean that BLEU score is low?

● The BLEU score is a metric used to evaluate the quality of machine translation. It compares the machine-translated text with one or more reference translations made by humans. ● A low BLEU score indicates that the machine translation significantly differs from the human reference translation. This could be due to various factors, such as: - Inaccurate translation, - Incorrect word choice or grammatical errors, - Lack of matching with the context or style of the reference translation.

Describe the formula of the Attention layer. In which cases Attention mechanism may be preferable over recurrent approach?

● The formula for the attention layer, especially in the context of transformers (like in BERT or GPT models), is usually expressed as: attention(q, k, v) = softmax(qk^t / sqrt(d_k)) v Where: Q is the query matrix, K is the key matrix, V is the value matrix, dk​ is the dimensionality of the keys, softmax is the softmax function applied row-wise. ● Cases - Handling Long Sequences: Recurrent Neural Networks (RNNs) often suffer from the vanishing gradient problem when dealing with long sequences, while the attention mechanism effectively captures long-distance dependencies. - Parallel Processing: Unlike RNNs, the attention mechanism allows for parallel processing of all sequence elements, which speeds up both training and inference. - Better Context Understanding: The attention mechanism gives the model the ability to better understand context and relationships in data, which is especially important in natural language processing tasks. - Flexibility in Application: The attention mechanism is easily adaptable to various tasks and data types, whereas RNNs are primarily optimized for sequential data. - Efficiency in Dealing with Hierarchical Structures: In some cases, such as image analysis or complex text structures, the attention mechanism can more effectively account for hierarchical relationships.

What is the most important layer in the Transformer architecture? What is its purpose

● The most critical component of the Transformer architecture is the Attention Mechanism. Its primary role is to highlight important parts of the input data when processing each element of the sequence. Transformers use the "multi-head attention" mechanism, which allows the model to focus on different aspects of the information simultaneously. ● Purpose of the Attention Mechanism: - Understanding Context: The attention mechanism helps the model capture contextual dependencies, regardless of the distance between words in the text. - Enhancing Data Representation: Attention allows the model to dynamically select the most relevant information fragments from the entire sequence. - Parallel Processing: Compared to RNNs and LSTMs, the attention mechanism enables processing all elements of a sequence in parallel, significantly speeding up training and inference.

Main Difficulties in Training GANs

● Training Instability: GANs are challenging to train due to the competitive training dynamics between the generator and discriminator. This can lead to instability where one network overpowers the other. ● Convergence Issues: Achieving convergence in GANs can be difficult as finding the perfect balance between the generator and discriminator is challenging. ● Mode Collapse: Occurs when the generator starts producing a limited variety of outputs despite the diversity in input data. ● Quality Assessment Challenges: Assessing the quality of generated images or data is not always clear or objective, making it difficult to evaluate GAN performance. ● Sensitivity to Hyperparameters: GANs are often sensitive to the choice of hyperparameters, such as learning rate, network architecture, and loss function.

Batch normalization

● is a technique used in neural networks to stabilize and speed up training. It normalizes the output of each layer to have a mean of 0 and a standard deviation of 1. ● A batch normalization layer is typically added after layers of the network but before the activation function. It is especially useful in deep networks, where gradient propagation problems can slow down training or lead to instability.

Inference Mode

● Определение: Режим инференса в контексте машинного обучения и нейронных сетей относится к использованию обученной модели для выполнения предсказаний на новых данных. В отличие от обучения, когда модель настраивается и обновляется, в режиме инференса модель уже обучена и используется для получения выводов или результатов из входных данных. ● Ключевые Особенности Режима Инференса: - Модель Не Обновляется: Веса и параметры модели остаются неизменными, поскольку процесс обучения уже завершен. - Быстродействие: Важно обеспечить высокую скорость обработки данных, поскольку инференс часто выполняется в реальном времени или в условиях, требующих быстрого реагирования. - Точность и Надежность: Модель должна обеспечивать высокую точность и надежность предсказаний. - Отключение Некоторых Техник Регуляризации: Такие методы, как Dropout или Batch Normalization, могут работать по-разному или быть полностью отключены во время инференса.