English
stringlengths 2
2.26k
| French
stringlengths 2
1.87k
⌀ |
|---|---|
We give a brief introduction to supervised learning using artificial neural networks. We expound on the problem formulation and conventions of data used to train these networks. We also discuss how to train a neural network for multi class classification, and how to perform inference once the network is trained. | Nous présentons brièvement l’apprentissage supervisé pour les réseaux neuronaux artificiels. Nous exposons la formulation du problème et les conventions des données utilisées pour entraîner ces réseaux. Nous discutons également de la manière d’entraîner un réseau neuronal pour la classification multiclasses et de la manière d’effectuer l’inférence une fois le réseau entraîné. |
ntroduction to Gradient Descent and Backpropagation Algorithm | Introduction à la descente de gradient et à l’algorithme de rétropropagation |
Gradient Descent optimization algorithm | Algorithme de l’optimisation de la descente de gradient |
Parametrised models | Modèles paramétrés |
Parametrised models are simply functions that depend on inputs and trainable parameters. There is no fundamental difference between the two, except that trainable parameters are shared across training samples whereas the input varies from sample to sample. In most deep learning frameworks, parameters are implicit, that is, they aren’t passed when the function is called. They are ‘saved inside the function’, so to speak, at least in the object-oriented versions of models. | Les modèles paramétrés sont simplement des fonctions qui dépendent d’entrées et de paramètres pouvant être entrainés. Il n’y a pas de différence fondamentale entre les deux, si ce n’est que les paramètres pouvant être entrainés sont partagés entre les échantillons d’entraînement alors que l’entrée varie d’un échantillon à l’autre. Dans la plupart des cadres d’apprentissage profond, les paramètres sont implicites, c’est-à-dire qu’ils ne sont pas transmis lorsque la fonction est appelée. Ils sont « enregistrés dans la fonction », pour ainsi dire, du moins dans les versions orientées objet des modèles. |
The parametrised model (function) takes in an input, has a parameter vector and produces an output. In supervised learning, this output goes into the cost function C(y,yˉ), which compares the true output (y) with the model output (yˉ). The computation graph for this model is shown in Figure 1. | Le modèle paramétré prend une entrée, possède un vecteur de paramètres et produit une sortie. Dans l’apprentissage supervisé, cette sortie va dans la fonction de coût C(y,yˉ), qui compare la sortie réelle y avec la sortie du modèle yˉ. Le graphe de calcul pour ce modèle est présenté à la figure 1. |
Examples of parametrised functions - | Exemples de fonctions paramétrées : |
Linear Model - Weighted Sum of Components of the Input Vector : | Modèle linéaire : la somme pondérée des composantes du vecteur d’entrée : |
Nearest Neighbour - There is an input x and a weight matrix W with each row of the matrix indexed by k. The output is the value of k that corresponds to the row of W that is closest to x: | Voisin le plus proche : il y a une entrée x et une matrice de poids W avec chaque ligne de la matrice indexée par k. La sortie est la valeur de k qui correspond à la ligne de W la plus proche de x : |
Parameterized models could also involve complicated functions. | Les modèles paramétrés peuvent également comporter des fonctions compliquées. |
Variables (tensor, scalar, continuous, discrete) | Variables (tenseur, scalaire, continues, discrètes) : |
is an observed input to the system | est une entrée observée dans le système |
is a computed variable which is produced by a deterministic function | est une variable calculée qui est produite par une fonction déterministe |
Deterministic functions | Fonctions déterministes |
Takes in multiple inputs and can produce multiple outputs | Prend en compte de multiples entrées et peut produire de multiples sorties |
It has an implicit parameter variable (ww) | Possède une variable paramètre implicite (ww) |
The rounded side indicates the direction in which it is easy to compute. In the above diagram, it is easier to compute yˉ from x than the other way around | Le côté arrondi indique la direction dans laquelle c’est plus facile à calculer. Dans le diagramme ci-dessus, il est plus facile de calculer yˉ à partir de x que l’inverse |
Scalar-valued function | Fonction à valeur scalaire |
Used to represent cost functions | Utilisée pour représenter les fonctions de coût |
Has an implicit scalar output | A une sortie scalaire implicite |
Takes multiple inputs and outputs a single value (usually the distance between the inputs) | Prend plusieurs entrées et produit une seule valeur (généralement la distance entre les entrées) |
Loss functions | Fonctions de perte |
Loss function is a function that is minimized during training. There are two types of losses: | Une fonction de perte est une fonction qui est minimisée pendant l’entraînement. Il existe deux types de pertes : |
1) Per Sample Loss - | 1) Perte par échantillon : |
2) Average Loss - | Perte moyenne : |
In the standard Supervised Learning paradigm, the loss (per sample) is simply the output of the cost function. Machine Learning is mostly about optimizing functions (usually minimizing them). It could also involve finding Nash Equilibria between two functions like with GANs. This is done using Gradient Based Methods, though not necessarily Gradient Descent. | Dans le paradigme standard de l’apprentissage supervisé, la perte (par échantillon) est simplement le résultat de la fonction de coût. L’apprentissage machine consiste principalement à optimiser les fonctions (généralement en les minimisant). Il peut également s’agir de trouver des équilibres de Nash entre deux fonctions, comme dans le cas des GANs (Generative adversarial networks). Cela se fait en utilisant des méthodes basées sur le gradient, mais pas nécessairement sur la descente du gradient. |
Gradient descent | Descente de gradient |
A Gradient Based Method is a method/algorithm that finds the minima of a function, assuming that one can easily compute the gradient of that function. It assumes that the function is continuous and differentiable almost everywhere (it need not be differentiable everywhere). | Une méthode basée sur le gradient est une méthode/algorithme qui trouve les minima d’une fonction, en supposant que l’on peut facilement calculer le gradient de cette fonction. Elle suppose que la fonction est continue et différentiable presque partout (il n’est pas nécessaire qu’elle soit différentiable partout). |
Gradient Descent Intuition - Imagine being in a mountain in the middle of a foggy night. Since you want to go down to the village and have only limited vision, you look around your immediate vicinity to find the direction of steepest descent and take a step in that direction. | Intuition de la descente du gradient : |
Different methods of Gradient Descent | Imaginez que vous êtes dans une montagne au milieu d’une nuit brumeuse. Comme vous voulez descendre jusqu’au village et que vous n’avez qu’une vision limitée, vous regardez autour de vous pour trouver la direction de la descente la plus raide et faites un pas dans cette direction. |
Full (batch) gradient descent update rule : | Mise à jour de la descente de gradient complète (par batch) : |
For SGD (Stochastic Gradient Descent), the update rule becomes : | Pour la SGD (la Descente de Gradient Stochastique de l’anglais Stochastic Gradient Descent), la règle de mise à jour devient : |
Where w represents the parameter to be optimized. | où w représente le paramètre à optimiser. |
η is a constant here but in more sophisticated algorithms, it could be a matrix. | η est une constante ici mais dans des algorithmes plus sophistiqués, il pourrait s’agir d’une matrice. |
If it is a positive semi-definite matrix, we’ll still move downhill but not necessarily in the direction of steepest descent. In fact the direction of steepest descent may not always be the direction we want to move in. | Si c’est une matrice semi-définie positive, nous continuerons à descendre, mais pas nécessairement dans le sens de la descente la plus raide. En fait, la direction de la descente la plus raide n’est pas toujours celle dans laquelle nous voulons aller. |
If the function is not differentiable, i.e, it has a hole or is staircase like or flat, where the gradient doesn’t give you any information, one has to resort to other methods - called 0-th Order Methods or Gradient-Free Methods. Deep Learning is all about Gradient Based Methods. | Si la fonction n’est pas différentiable, c’est-à-dire si elle a un trou, si elle est en forme d’escalier ou si elle est plate (la pente ne donne alors aucune information), il faut recourir à d’autres méthodes appelées méthodes d’ordre 0 ou méthodes sans gradient. L’apprentissage profond est une méthode basée sur le gradient. |
However, RL (Reinforcement Learning) involves Gradient Estimation without the explicit form for the gradient. An example is a robot learning to ride a bike where the robot falls every now and then. The objective function measures how long the bike stays up without falling. Unfortunately, there is no gradient for the objective function. The robot needs to try different things. | Cependant, le RL (Apprentissage par renforcement de l’anglais Reinforcement Learning) implique une estimation du gradient sans la forme explicite du gradient. Un exemple est un robot apprenant à faire du vélo où le robot tombe de temps en temps. La fonction objectif mesure la durée pendant laquelle le vélo reste debout sans tomber. Malheureusement, il n’y a pas de gradient pour la fonction objectif. Le robot doit essayer différentes choses. |
The RL cost function is not differentiable most of the time but the network that computes the output is gradient-based. This is the main difference between supervised learning and reinforcement learning. With the latter, the cost function c is not differentiable. In fact it completely unknown. It just returns an output when inputs are fed to it, like a blackbox. This makes it highly inefficient and is one of the main drawbacks of RL - particularly when the parameter vector is high dimensional (which implies a huge solution space to search in, making it hard to find where to move). | La fonction de coût en RL n’est pas différenciable la plupart du temps, mais le réseau qui calcule la sortie est basé sur un gradient. C’est la principale différence entre l’apprentissage supervisé et l’apprentissage par renforcement. Dans ce dernier cas, la fonction de coût c n’est pas différenciable. En fait, elle est totalement inconnue. Elle renvoie simplement une sortie lorsque des entrées lui sont fournies, comme une boîte noire. Cela la rend très inefficace et constitue l’un des principaux inconvénients du RL. En particulier lorsque le vecteur de paramètres est à haute dimension (ce qui implique un énorme espace de solution à rechercher, rendant difficile de trouver où se déplacer). |
A very popular technique in RL is Actor Critic Methods. A critic method basically consists of a second C module which is a known, trainable module. One is able to train the C module, which is differentiable, to approximate the cost function/reward function. The reward is a negative cost, more like a punishment. That’s a way of making the cost function differentiable, or at least approximating it by a differentiable function so that one can backpropagate. | Une technique très populaire en RL est la méthode Acteur-Critique (AC). Une méthode critique consiste essentiellement en un second module C qui est un module connu et pouvant être entraîné. On peut entraîner le module C, qui est différenciable, à se rapprocher de la fonction de coût / fonction de récompense. La récompense est un coût négatif, pouvant être vue comme une punition. C’est une façon de rendre la fonction de coût différentiable, ou du moins de l’approcher par une fonction différentiable afin de pouvoir faire de la rétropropagation. |
Advantages of SGD and backpropagation for traditional neural nets | Avantages de la SGD et de la rétropropagation pour les réseaux de neurones traditionnels |
Advantages of Stochastic Gradient Descent (SGD) | Avantages de la descente de gradient stochastique (SGD) |
In practice, we use stochastic gradient to compute the gradient of the objective function w.r.t the parameters. Instead of computing the full gradient of the objective function, which is the average of all samples, stochastic gradient just takes one sample, computes the loss, L, and the gradient of the loss w.r.t the parameters, and then takes one step in the negative gradient direction. | En pratique, nous utilisons un gradient stochastique pour calculer le gradient de la fonction objectif sans les paramètres. Au lieu de calculer le gradient complet de la fonction objectif, qui est la moyenne de tous les échantillons, le gradient stochastique ne prend qu’un échantillon, calcule la perte L, et le gradient de la perte avec les paramètres. Puis on fait un pas dans la direction du gradient négatif. |
In the formula, W is approached by W minus the step-size, times the gradient of the per-sample loss function w.r.t the parameters for a given sample, (x[p],y[p]). | Dans la formule, w est approché par W moins la taille du pas, multiplié par le gradient de la fonction de perte par échantillon avec les paramètres pour un échantillon donné, (x[p],y[p]). |
If we do this on a single sample, we will get a very noisy trajectory as shown in Figure 3. Instead of the loss going directly downhill, it’s stochastic. Every sample will pull the loss towards a different direction. It’s just the average that pulls us to the minimum of the average. Although it looks inefficient, it’s much faster than full batch gradient descent at least in the context of machine learning when the samples have some redundancy. | Si nous faisons cela sur un seul échantillon, nous obtenons une trajectoire très bruyante comme le montre la figure 3. Au lieu que la perte soit directement descendante, elle est stochastique. Chaque échantillon tire la perte vers une direction différente. En prendre la moyenne nous tire au minimum de la moyenne. Bien que cela semble inefficace, c’est beaucoup plus rapide que la descente par batch, au moins dans le contexte de l’apprentissage machine, lorsque les échantillons ont une certaine redondance. |
In practice, we use batches instead of doing stochastic gradient descent on a single sample. We compute the average of the gradient over a batch of samples, not a single sample, and then take one step. The only reason for doing this is that we can make more efficient use of the existing hardware (i.e. GPUs, multicore CPUs) if we use batches since it’s easier to parallelize. Batching is the simplest way to parallelize. | En pratique, nous utilisons des batchs (des lots) au lieu de faire une descente de gradient stochastique sur un seul échantillon. Nous calculons la moyenne du gradient sur un lot d’échantillons, et non sur un seul échantillon, puis nous effectuons une étape. La seule raison pour laquelle nous faisons cela est que nous pouvons utiliser plus efficacement le matériel existant (c’est-à-dire les GPUs, les CPUs multi-cœurs) car il est plus facile de les paralléliser. La mise en lots est la façon la plus simple de paralléliser. |
Traditional neural network | Réseau neuronal traditionnel |
Traditional Neural Nets are basically interspersed layers of linear operations and point-wise non-linear operations. For linear operations, conceptually it is just a matrix-vector multiplication. We take the (input) vector multiplied by a matrix formed by the weights. The second type of operation is to take all the components of the weighted sums vector and pass it through some simple non-linearity (i.e. ReLU(⋅),tanh(⋅), …). | Les réseaux neuronaux traditionnels sont essentiellement des couches intercalées d’opérations linéaires et d’opérations non linéaires ponctuelles. Pour les opérations linéaires, il s’agit conceptuellement d’une simple multiplication matrice-vecteur. Nous prenons le vecteur (d’entrée) multiplié par une matrice formée par les poids. Le deuxième type d’opération consiste à prendre toutes les composantes du vecteur des sommes pondérées et à les faire passer par une simple non-linéarité (c’est-à-dire ReLU(⋅),tanh(⋅), …). |
Figure 4 is an example of a 2-layer network, because what matters are the pairs (i.e linear+non-linear). Some people call it a 3-layer network because they count the variables. Note that if there are no non-linearities in the middle, we may as well have a single layer because the product of two linear functions is a linear function. | La figure 4 est un exemple de réseau à deux couches, car ce sont les paires (c’est-à-dire linéaire+non linéaire) qui comptent. Certaines personnes l’appellent un réseau à 3 couches parce qu’elles comptent les variables. Notez que s’il n’y a pas de non-linéarités au milieu, nous pouvons tout aussi bien avoir une seule couche car le produit de deux fonctions linéaires est une fonction linéaire. |
Figure 5 shows how the linear and non-linear functional blocks of the network stack: | La figure 5 montre comment les blocs fonctionnels linéaires et non linéaires du réseau s’empilent : |
Backpropagation through a non-linear function | Rétropropagation par une fonction non linéaire |
The first way to do backpropagation is to backpropagate through a non linear function. We take a particular non-linear function h from the network and leave everything else in the blackbox. | La première façon de faire de la rétropropagation est de rétropropager par une fonction non linéaire. Nous prenons une fonction non linéaire particulière h du réseau et nous laissons tout le reste dans la boîte noire. |
We are going to use the chain rule to compute the gradients: | Nous allons utiliser la règle de la chaîne pour calculer les gradients : |
Hence if we have a chain of those functions in the network, we can backpropagate by multiplying by the derivatives of all the h functions one after the other all the way back to the bottom. | Par conséquent, si nous avons une chaîne de ces fonctions dans le réseau, nous pouvons faire une rétropropagation en multipliant par les dérivées de toutes les fonctions h l’une après l’autre jusqu’au fond. |
It’s more intuitive to think of it in terms of perturbations. Perturbing s by ds will perturb z by: | Il est plus intuitif de penser en termes de perturbations. Perturber s par ds perturbera z par : |
This would in turn perturb C by: | Cela perturbera à son tour C par : |
Once again, we end up with the same formula as the one shown above. | Une fois de plus, nous nous retrouvons avec la même formule que celle présentée ci-dessus. |
Backpropagation through a weighted sum | Rétropropagation par une somme pondérée |
For a linear module, we do backpropagation through a weighted sum. Here we view the entire network as a blackbox except for 3 connections going from a z variable to a bunch of s variables. | Pour un module linéaire, nous faisons la rétropropagation par une somme pondérée. Ici, nous considérons l’ensemble du réseau comme une boîte noire, à l’exception de 3 connexions allant d’une variable z à un tas de variables s. |
We can implement neural nets with object oriented classes in PyTorch. First we define a class for the neural net and initialize linear layers in the constructor using predefined nn.Linear class. Linear layers have to be separate objects because each of them contains a parameter vector. The nn.Linear class also adds the bias vector implicitly. Then we define a forward function on how to compute outputs with torch.relu function as the nonlinear activation. We don’t have to initialize separate relu functions because they don’t have parameters. | Nous pouvons implémenter des réseaux neuronaux avec des classes orientées objet dans PyTorch. Tout d’abord, nous définissons une classe pour le réseau neuronal et nous initialisons les couches linéaires dans le constructeur en utilisant la classe prédéfinie nn.Linear. Les couches linéaires doivent être des objets séparés car chacune d’entre elles contient un vecteur de paramètres. La classe nn.Linear ajoute aussi implicitement le vecteur de biais. Ensuite, nous définissons une fonction directe sur la façon de calculer les sorties avec la fonction torch.relu comme activation non linéaire. Nous n’avons pas besoin d’initialiser des fonctions ReLU séparées car elles n’ont pas de paramètres. |
We do not need to compute the gradient ourselves since PyTorch knows how to back propagate and calculate the gradients given the forward function. | Nous n’avons pas besoin de calculer le gradient nous-mêmes puisque PyTorch sait comment propager en arrière et calculer les gradients avec la fonction forward. |
Backprop through a functional module | Rétropropagation par le biais d’un module fonctionnel |
We now present a more generalized form of backpropagation. | Nous présentons maintenant une forme plus généralisée de rétropropagation. |
Backprop through a multi-stage graph | Rétropropagation par le biais d’un graphe à plusieurs niveaux |
Consider a stack of many modules in a neural network as shown in Figure 9. | Considérons une pile de plusieurs modules dans un réseau de neurones, comme le montre la figure 9. |
For the backprop algorithm, we need two sets of gradients - one with respect to the states (each module of the network) and one with respect to the weights (all the parameters in a particular module). So we have two Jacobian matrices associated with each module. We can again use chain rule for backprop. | Pour l’algorithme de rétropropagation, nous avons besoin de deux ensembles de gradients : un par rapport aux états (chaque module du réseau) et un par rapport aux poids (tous les paramètres d’un module particulier). Nous avons donc deux matrices jacobiennes associées à chaque module. Nous pouvons à nouveau utiliser la règle de la chaîne pour la rétropropagation. |
Week 3 | Semaine 3 |
We first see a visualization of a 6-layer neural network. Next we begin with the topic of Convolutions and Convolution Neural Networks (CNN). We review several types of parameter transformations in the context of CNNs and introduce the idea of a kernel, which is used to learn features in a hierarchical manner. Thereby allowing us to classify our input data which is the basic idea motivating the use of CNNs. | Nous voyons d’abord une visualisation d’un réseau de neurones à 6 couches. Ensuite, nous commençons par le sujet des convolutions et des réseaux neuronaux à convolution (ConvNets). Nous passons en revue plusieurs types de transformations de paramètres dans le contexte des ConvNets et introduisons l’idée d’un noyau, qui est utilisé pour apprendre des caractéristiques de manière hiérarchique. Cela nous permet de classer nos données d’entrée, ce qui est l’idée de base motivant l’utilisation des ConvNets. |
We give an introduction on how CNNs have evolved over time. We discuss in detail different CNN architectures, including a modern implementation of LeNet5 to exemplify the task of digit recognition on the MNIST dataset. Based on its design principles, we expand on the advantages of CNNs which allows us to exploit the compositionality, stationarity, and locality features of natural images. | Nous présentons l’évolution des ConvNets au fil du temps. Nous discutons en détails des différentes architectures de ConvNets, y compris une implémentation moderne de LeNet5 pour illustrer la tâche de reconnaissance des chiffres sur le jeu de données du MNIST. Sur la base des principes de conception, nous développons les avantages des ConvNets qui nous permettent d’exploiter les caractéristiques de compositionnalité, de stationnarité et de localisation des images naturelles. |
Properties of natural signals that are most relevant to CNNs are discussed in more detail, namely: Locality, Stationarity, and Compositionality. We explore precisely how a kernel exploits these features through sparsity, weight sharing and the stacking of layers, as well as motivate the concepts of padding and pooling. Finally, a performance comparison between FCN and CNN was done for different data modalities. | Nous discutons des propriétés des signaux naturels qui sont les plus pertinentes pour les ConvNets. A savoir la localité, la stationnarité et la compositionnalité. Nous explorons précisément comment un noyau exploite ces caractéristiques par l’éparsité, le partage des poids et l’empilement des couches puis abordons les concepts de rembourrage et de pooling. Enfin, une comparaison des performances entre les réseaux entièrement connectés et les ConvNets est effectuée pour différents types de données. |
Visualization of neural networks parameter transformation and fundamental concepts of convolution | Visualisation de la transformation des paramètres des réseaux neuronaux et concepts fondamentaux de la convolution |
Visualization of neural networks | Visualisation des réseaux de neurones |
In this section we will visualize the inner workings of a neural network. | Dans cette section, nous allons visualiser le fonctionnement interne d’un réseau de neurones. |
Figure 1 depicts the structure of the neural network we would like to visualize. Typically, when we draw the structure of a neural network, the input appears on the bottom or on the left, and the output appears on the top side or on the right. In Figure 1, the pink neurons represent the inputs, and the blue neurons represent the outputs. In this network, we have 4 hidden layers (in green), which means we have 6 layers in total (4 hidden layers + 1 input layer + 1 output layer). In this case, we have 2 neurons per hidden layer, and hence the dimension of the weight matrix (W) for each layer is 2-by-2. This is because we want to transform our input plane into another plane that we can visualize. | La figure 1 illustre la structure du réseau de neurones que nous souhaitons visualiser. En général, lorsque nous dessinons la structure d’un réseau de neurones, l’entrée apparaît en bas ou à gauche et la sortie apparaît en haut ou à droite. Dans la figure 1, les neurones roses représentent les entrées et les neurones bleus les sorties. Dans ce réseau, nous avons 4 couches cachées (en vert), ce qui signifie que nous avons 6 couches au total (4 couches cachées + 1 couche d’entrée + 1 couche de sortie). Dans ce cas, nous avons 2 neurones par couche cachée et donc la dimension de la matrice de poids (W) pour chaque couche est de 2 par 2. Cela s’explique par le fait que nous voulons transformer notre plan d’entrée en un autre plan que nous pouvons visualiser. |
The transformation of each layer is like folding our plane in some specific regions as shown in Figure 2. This folding is very abrupt, this is because all the transformations are performed in the 2D layer. In the experiment, we find that if we have only 2 neurons in each hidden layer, the optimization will take longer; the optimization is easier if we have more neurons in the hidden layers. This leaves us with an important question to consider: Why is it harder to train the network with fewer neurons in the hidden layers? You should consider this question yourself and we will return to it after the visualization of ReLU. | La transformation de chaque couche est comme le pliage de notre plan dans certaines régions spécifiques, comme le montre la figure 2. Ce pliage est très abrupt, car toutes les transformations sont effectuées dans la couche 2D. Expérimentalement, nous constatons que si nous n’avons que 2 neurones dans chaque couche cachée, l’optimisation prend plus de temps. L’optimisation est plus facile si nous avons davantage de neurones dans les couches cachées. Cela nous laisse avec une question importante à considérer : pourquoi est-il plus difficile d’entraîner le réseau avec moins de neurones dans les couches cachées ? |
When we step through the network one hidden layer at a time, we see that with each layer we perform some affine transformation followed by applying the non-linear ReLU operation, which eliminates any negative values. In Figures 3(a) and (b), we can see the visualization of ReLU operator. The ReLU operator helps us to do non-linear transformations. After multiple steps of performing an affine transformation followed by the ReLU operator, we are eventually able to linearly separate the data as can be seen in Figure 4. | Lorsque nous parcourons le réseau une couche cachée à la fois, nous constatons qu’avec chaque couche, nous effectuons une certaine transformation affine suivie de l’application de l’opération non linéaire ReLU, qui élimine toute valeur négative. Dans les figures 3(a) et (b), nous pouvons voir la visualisation de l’opérateur ReLU. L’opérateur ReLU nous aide à effectuer des transformations non linéaires. Après avoir effectué plusieurs étapes de transformation affine suivies par l’opérateur ReLU, nous sommes finalement en mesure de séparer les données de manière linéaire, comme le montre la figure 4. |
This provides us with some insight into why the 2-neuron hidden layers are harder to train. Our 6-layer network has one bias in each hidden layer. Therefore, if one of these biases moves points out of top-right quadrant, then applying the ReLU operator will eliminate these points to zero. After that, no matter how later layers transform the data, the values will remain zero. We can make a neural network easier to train by making the network “fatter” - i.e. adding more neurons in hidden layers - or we can add more hidden layers, or a combination of the two methods. Throughout this course we will explore how to determine the best network architecture for a given problem, stay tuned. | Elle nous permet de comprendre pourquoi les couches cachées à deux neurones sont plus difficiles à entraîner. Notre réseau à 6 couches a un biais dans chaque couche cachée. Par conséquent, si l’un de ces biais déplace des points hors du quadrant supérieur droit, l’application de l’opérateur ReLU éliminera ces points. Ensuite, quelle que soit la façon dont les couches ultérieures transforment les données, les valeurs resteront nulles. Nous pouvons rendre un réseau de neurones plus facile à entraîner en rendant le réseau plus « gros » (c’est-à-dire en ajoutant plus de neurones dans les couches cachées) ou nous pouvons ajouter d’autres couches cachées, ou une combinaison des deux méthodes. |
Parameter transformations | Transformations des paramètres |
General parameter transformation means that our parameter vector W is the output of a function. By this transformation, we can map original parameter space into another space. In Figure 5, w is actually the output of H with the parameter uu. G(x,w) is a network and C(y,yˉ) is a cost function. The backpropagation formula is also adapted as follows | La transformation générale des paramètres signifie que notre vecteur de paramètres W est la sortie d’une fonction. Par cette transformation, nous pouvons faire correspondre l’espace de paramètres d’origine à un autre espace. Dans la figure 5, w est en fait la sortie de H avec le paramètre uu. G(x,w) est un réseau et C(y,yˉ) est une fonction de coût. La formule de rétropropagation est également adaptée comme suit : |
A simple parameter transformation: weight sharing | Une transformation des paramètres simple : le partage des poids |
A Weight Sharing Transformation means H(u) just replicates one component of u into multiple components of w. H(u) is like a Y branch to copy u1 to w1, w2. This can be expressed as, | Le partage des poids signifie que H(u) reproduit simplement une composante de u en plusieurs composantes de w. H(u) est comme une branche Y pour copier u1 en w1, w2. Cela peut être exprimé sous la forme : |
We force shared parameters to be equal, so the gradient w.r.t. to shared parameters will be summed in the backprop. For example the gradient of the cost function C(y,yˉ) with respect to u1 will be the sum of the gradient of the cost function C(y,yˉ) with respect to w1 and the gradient of the cost function C(y,yˉ) with respect to w2. | Nous forçons les paramètres partagés à être égaux, de sorte que le gradient par rapport aux paramètres partagés sera additionné dans la rétropropagation. Par exemple, le gradient de la fonction de coût C(y,yˉ) par rapport à u1 sera la somme du gradient de la fonction de coût C(y,yˉ) par rapport à w1 et du gradient de la fonction de coût C(y,yˉ) par rapport à w2. |
Hypernetwork | Hyper-réseau |
A hypernetwork is a network where the weights of one network is the output of another network. Figure 6 shows the computation graph of a “hypernetwork”. Here the function H is a network with parameter vector u and input x. As a result, the weights of G(x,w) are dynamically configured by the network H(x,u). Although this is an old idea, it remains very powerful. | Un hyper-réseau est un réseau où les poids d’un réseau sont la sortie d’un autre réseau. La figure 6 montre le graphique de calcul d’un hyper-réseau. Ici, la fonction H est un réseau avec le vecteur paramètre u et l’entrée x. En conséquence, les poids de G(x,w) sont configurés dynamiquement par le réseau H(x,u). Bien que cette idée soit ancienne, elle reste très puissante. |
Motif detection in sequential data | Détection de motifs dans les données séquentielles |
Weight sharing transformation can be applied to motif detection. Motif detection means to find some motifs in sequential data like keywords in speech or text. One way to achieve this, as shown in Figure 7, is to use a sliding window on data, which moves the weight-sharing function to detect a particular motif (i.e. a particular sound in speech signal), and the outputs (i.e. a score) goes into a maximum function. | La partage de poids peut être appliqué à la détection de motifs. La détection de motifs consiste à trouver certains motifs dans des données séquentielles comme des mots-clés dans la parole ou le texte. Une façon d’y parvenir, comme le montre la figure 7, consiste à utiliser une fenêtre coulissante sur les données, qui déplace la fonction de partage de poids pour détecter un motif particulier (c’est-à-dire un son particulier dans le signal vocal) et les sorties (c’est-à-dire une partition) passent dans une fonction maximale. |
In this example we have 5 of those functions. As a result of this solution, we sum up five gradients and backpropagate the error to update the parameter w. When implementing this in PyTorch, we want to prevent the implicit accumulation of these gradients, so we need to use zero_grad() to initialize the gradient. | Dans cet exemple, nous avons cinq de ces fonctions. Cette solution nous permet d’additionner cinq gradients et de rétropropager l’erreur pour mettre à jour le paramètre w. En implémentant cela dans PyTorch, nous voulons empêcher l’accumulation implicite de ces gradients, donc nous devons utiliser zero_grad() pour initialiser le gradient. |
Motif detection in images | Détection de motifs dans les images |
The other useful application is motif detection in images. We usually swipe our “templates” over images to detect the shapes independent of position and distortion of the shapes. A simple example is to distinguish between “C” and “D”, as Figure 8 shows. The difference between “C” and “D” is that “C” has two endpoints and “D” has two corners. So we can design “endpoint templates” and “corner templates”. If the shape is similar to the “templates”, it will have thresholded outputs. Then we can distinguish letters from these outputs by summing them up. In Figure 8, the network detects two endpoints and zero corners, so it activates “C”. | L’autre application utile est la détection de motifs dans les images. Nous faisons généralement glisser nos patrons sur les images pour détecter les formes indépendamment de leur position et de leur distorsion. Un exemple simple consiste à distinguer un « C » d’un « D », comme le montre la figure 8. La différence entre « C » et « D » est que « C » a deux extrémités et « D » a deux coins. Nous pouvons donc concevoir des patrons d’extrémité et des patrons d’angle. Si la forme est similaire aux patrons, les sorties seront limitées. Nous pouvons alors distinguer les lettres de ces sorties en les additionnant. Dans la figure 8, le réseau détecte deux points d’extrémité et zéro coin, donc il active « C ». |
It is also important that our “template matching” should be shift-invariant - when we shift the input, the output (i.e. the letter detected) shouldn’t change. This can be solved with weight sharing transformation. As Figure 9 shows, when we change the location of “D”, we can still detect the corner motifs even though they are shifted. When we sum up the motifs, it will activate the “D” detection. | Il est également important que notre appariement de pochoirs (template matching en anglais) soit invariable par décalage : lorsque nous décalons l’entrée, la sortie (c’est-à-dire la lettre détectée) ne doit pas changer. Ce problème peut être résolu par une transformation de type partage de poids. Comme le montre la figure 9, lorsque nous changeons l’emplacement de « D », nous pouvons toujours détecter les motifs de coin même s’ils sont décalés. Lorsque nous additionnons les motifs, cela active la détection de « D ». |
This hand-crafted method of using local detectors and summation to for digit-recognition was used for many years. But it presents us with the following problem: How can we design these “templates” automatically? Can we use neural networks to learn these “templates”? Next, We will introduce the concept of convolutions, that is, the operation we use to match images with “templates”. | Cette méthode artisanale d’utilisation de détecteurs locaux et de sommation pour la reconnaissance des chiffres a été utilisée pendant de nombreuses années. Mais elle nous pose le problème suivant : comment pouvons-nous concevoir ces pochoirs automatiquement ? Pouvons-nous utiliser des réseaux de neurones pour apprendre ces pochoirs ? Pour cela nous allons introduire le concept de convolutions, c’est-à-dire l’opération que nous utilisons pour faire correspondre les images avec les pochoirs. |
Discrete convolution | Convolution discrète |
Convolution | Convolution |
The precise mathematical definition of a convolution in the 1-dimensional case between input x and w is: | La définition mathématique précise d’une convolution dans le cas unidimensionnel entre l’entrée x et w est : |
In words, the i-th output is computed as the dot product between the reversed w and a window of the same size in x. To compute the full output, start the window at the beginning, shift this window by one entry each time and repeat until x is exhausted. | En d’autres termes, la ii-ème sortie est calculée comme le produit scalaire entre les w inversés et une fenêtre de même taille en x. Pour calculer la sortie complète, on commence avec la fenêtre au début puis on décale cette fenêtre d’une entrée à chaque fois. On répète le procédé jusqu’à ce que x soit épuisé. |
Cross-correlation | Corrélation croisée |
In practice, the convention adopted in deep learning frameworks such as PyTorch is slightly different. Convolution in PyTorch is implemented where W is not reversed: | En pratique, la convention adoptée dans les frameworks d’apprentissage profond comme PyTorch est légèrement différente. La convolution dans PyTorch est mise en œuvre lorsque w est non inversé : |
Mathematicians call this formulation “cross-correlation”. In our context, this difference is just a difference in convention. Practically, cross-correlation and convolution can be interchangeable if one reads the weights stored in memory forward or backward. | Les mathématiciens appellent cette formulation « corrélation croisée ». Dans notre contexte, cette différence n’est qu’une différence de convention. En pratique, la corrélation croisée et la convolution peuvent être interchangeables si l’on lit les poids stockés en mémoire en avant ou en arrière. |
Being aware of this difference is important, for example, when one want to make use of certain mathematical properties of convolution/correlation from mathematical texts. | Il est important d’être conscient de cette différence, par exemple, lorsqu’on veut utiliser certaines propriétés mathématiques de la convolution/corrélation à partir de textes mathématiques. |
Higher dimensional convolution | Convolution de dimensions supérieures |
For two dimensional inputs such as images, we make use of the two-dimensional version of convolution: | Pour les entrées bidimensionnelles telles que les images, nous utilisons la version bidimensionnelle de la convolution : |