English
stringlengths 2
2.26k
| French
stringlengths 2
1.87k
⌀ |
|---|---|
Instead of solving the little optimization problem at every time step, why not use a big neural network to produce the required solution directly? Our hope is that we can train a neural network with sufficient complexity that it essentially solves the optimization problem in one step and produces an output that is as good as the solution obtained from solving the optimization problem at each time step. | Au lieu de résoudre le petit problème d’optimisation à chaque étape, pourquoi ne pas utiliser un grand réseau de neurones pour produire directement la solution requise ? Nous espérons pouvoir entraîner un réseau de neurones suffisamment complexe pour qu’il résolve le problème d’optimisation en une seule étape et produise un résultat aussi bon que la solution obtenue en résolvant le problème d’optimisation à chaque étape temporelle. |
where B is our deep learning model and y is the observed Fourier-domain data. | où B est notre modèle d’apprentissage profond et y est la donnée observée dans le domaine de Fourier. |
15 years ago, this approach was difficult – but nowadays this is a lot easier to implement. Figure 9 shows the result of a deep learning approach to this problem and we can see that the output is much better than the compressed sensing approach and looks very similar to the actual scan. | Il y a 15 ans, cette approche était difficile mais est aujourd’hui beaucoup plus facile à mettre en œuvre. La figure 9 montre le résultat d’une approche d’apprentissage profond au problème. Nous pouvons voir qu’il est bien meilleur que l’approche de détection comprimée et ressemble beaucoup au scanner réel. |
The model used to generate this reconstruction uses an ADAM optimizer, group-norm normalization layers, and a U-Net based convolutional neural network. Such an approach is very close to practical applications and we will hopefully be seeing these accelerated MRI scans happening in clinical practice in a few years’ time | Le modèle utilisé pour générer cette reconstruction fait appel à un optimiseur ADAM, à des couches de normalisation par groupes et à un ConvNet basé sur U-Net. |
Understanding convolutions and automatic differentiation engine | Comprendre les convolutions et autograd |
Understanding 1D convolution | Comprendre la convolution 1D |
Instead of using the matrix A discussed in the previous week, we will change the matrix width to the kernel size k. Therefore, each row of the matrix is a kernel. We can use the kernels by stacking and shifting (see Fig 1). Then we can have mm layers of height n−k+1. | Au lieu d’utiliser la matrice A de la semaine précédente, nous allons changer la largeur de la matrice pour la taille du noyau k. Par conséquent, chaque ligne de la matrice est un noyau. Nous pouvons utiliser les noyaux en les empilant et en les déplaçant (voir la figure 1). Nous pouvons alors avoir mm couches de hauteur n−k+1. |
The output is m (thickness) vectors of size n−k+1. | La sortie est m vecteurs de taille n−k+1. |
Furthermore, a single input vector can viewed as a monophonic signal. | De plus, un seul vecteur d’entrée peut être considéré comme un signal monophonique. |
where Ω={1,2,3,⋯ }⊂N1 (since this is 1 dimensional signal / it has a 1 dimensional domain) and in this case the channel number c is 1. When c=2 this becomes a stereophonic signal. | avec Ω={1,2,3,⋯}⊂N1 (puisque c’est un signal de dimension 1 / il a un domaine de dimension 1) et dans ce cas le numéro de canal c est 1. Lorsque c=2, cela devient un signal stéréophonique. |
For the 1D convolution, we can just compute the scalar product, kernel by kernel (see Fig 4). | Pour la convolution 1D, nous pouvons simplement calculer le produit scalaire, noyau par noyau (voir figure 4). |
Dimension of kernels and output width in PyTorch | Dimension des noyaux et largeur des sorties dans PyTorch |
Tips: We can use question mark in IPython to get access to the documents of functions. For example, | Astuce : on peut utiliser le question mark dans IPython pour avoir accès aux documents de fonctions. Par exemple, |
1D convolution | Convolution 1D |
We have 1 dimensional convolution going from 2 channels (stereophonic signal) to 16 channels (16 kernels) with kernel size of 3 and stride of 1. We then have 16 kernels with thickness 2 and length 3. Let’s assume that the input signal has a batch of size 1 (one signal), 2 channels and 64 samples. The resulting output layer has 1 signal, 16 channels and the length of the signal is 62 (=64−3+1). Also, if we output the bias size, we’ll find the bias size is 16, since we have one bias per weight. | Nous avons une convolution de dimension 1 allant de 2 canaux (signal stéréophonique) à 16 canaux (16 noyaux) avec une taille de noyau de 3 et un pas de 11. Nous avons ensuite 16 noyaux avec une épaisseur de 2 et une longueur de 3. Supposons que le signal d’entrée ait un batch de taille 1 (un signal), de 2 canaux et 64 échantillons. La couche de sortie résultante a 1 signal, des 16 canaux et la longueur du signal est de 62 (=64−3+1). De plus, si nous affichons la taille du biais, nous constaterons qu’elle de 16, puisque nous avons un biais par poids. |
2D convolution | Convolution 2D |
We first define the input data as 1 sample, 20 channels (say, we’re using an hyperspectral image) with height 64 and width 128. The 2D convolution has 20 channels from input and 16 kernels with size of 3×53×5. After the convolution, the output data has 1 sample, 16 channels with height 62 (=64−3+1) and width 124 (=128−5+1). | Nous définissons d’abord les données d’entrée comme un 1 échantillon, 20 canaux (disons que nous utilisons une image hyperspectrale) avec une hauteur de 64 et une largeur de 128. La convolution 2D a 20 canaux en entrée et 16 noyaux de taille de 3×53×5. Après la convolution, la donnée en sortie a un 1 échantillon, 16 canaux avec une hauteur de 62 (=64−3+1) et une largeur de 124 (=128−5+1). |
If we want to achieve the same dimensionality, we can have paddings. Continuing the code above, we can add new parameters to the convolution function: stride=1 and padding=(1, 2), which means 1 on y direction (1 at the top and 1 at the bottom) and 2 on x direction. Then the output signal is in the same size compared to the input signal. The number of dimensions that is required to store the collection of kernels when you perform 2D convolution is 4. | Si nous voulons atteindre la même dimensionnalité, nous pouvons rembourrer. En continuant le code ci-dessus, nous pouvons ajouter de nouveaux paramètres à la fonction de convolution : stride=1 et padding=(1, 2), ce qui signifie 1 dans la direction y (1 en haut et 1 en bas) et 2 dans la direction x. Le signal de sortie est alors de la même taille que le signal d’entrée. Le nombre de dimensions nécessaires pour stocker la collection de noyaux lorsque vous effectuez une convolution 2D est de 4. |
How automatic gradient works? | Comment fonctionne le gradient automatique ? |
In this section we’re going to ask torch to check all the computation over the tensors so that we can perform the computation of partial derivatives. | Dans cette section, nous allons demander à Pytorch de vérifier tous les calculs sur les tenseurs afin que nous puissions effectuer le calcul des dérivés partielles. |
From basic to more crazy | Vers plus de folie |
Now we have a 1×3 vector x, assign y to the double x and keep doubling y until its norm is smaller than 1000. Due to the randomness we have for x, we cannot directly know the number of iterations when the procedure terminates. | Maintenant que nous avons un vecteur 1×3 x, assignons 2x à y et doublons y jusqu’à ce que sa norme soit inférieure à 1000. En raison du caractère aléatoire que nous avons pour x, nous ne pouvons pas connaître directement le nombre d’itérations lorsque la procédure se termine. |
However, we can infer it easily by knowing the gradients we have. | Cependant, nous pouvons facilement le déduire en connaissant les gradients dont nous disposons. |
As for the inference, we can use requires_grad=True to label that we want to track the gradient accumulation as shown below. If we omit requires_grad=True in either x or w’s declaration and call backward() on z, there will be runtime error due to we do not have gradient accumulation on x or W. | Quant à l’inférence, nous pouvons utiliser requires_grad=True pour indiquer que nous voulons suivre l’accumulation du gradient comme indiqué ci-dessous. Si nous omettons requires_grad=True dans la déclaration de x ou w et appelons backward() sur z, il y aura une erreur d’exécution due au fait que nous n’avons pas d’accumulation de gradient sur x ou w. |
And, we can have with torch.no_grad() to omit the gradient accumulation. | Nous pouvons avoir with torch.no_grad() pour omettre l’accumulation de gradient. |
More stuff – custom gradients | Plus de choses : des gradients personnalisés |
Also, instead of basic numerical operations, we can generate our own self-defined modules / functions, which can be plugged into the neural graph. The Jupyter Notebook can be found here. | Au lieu d’opérations numériques de base, nous pouvons générer nos propres modules / fonctions qui peuvent être branchés sur le graphe neural. Le notebook Jupyter se trouve ici. |
To do so, we need to inherit torch.autograd.Function and override forward() and backward() functions. For example, if we want to training nets, we need to get the forward pass and know the partial derivatives of the input respect to the output, such that we can use this module in any kind of point in the code. Then, by using back-propagation (chain rule), we can plug the thing anywhere in the chain of operations, as long as we know the partial derivatives of the input respect to the output. | Pour ce faire, nous devons partir de la fonction torch.autograd.Function et remplacer les fonctions forward() et backward(). Par exemple, si nous voulons entraîner des réseaux, nous devons obtenir la propagation en avant dans le réseau et connaître les dérivées partielles de l’entrée par rapport à la sortie, de sorte que nous puissions utiliser ce module en tout point du code. Ensuite, en utilisant la rétropropagation (règle de la chaîne), nous pouvons insérer la chose n’importe où dans la chaîne d’opérations, à condition de connaître les dérivées partielles de l’entrée par rapport à la sortie. |
In this case, there are three examples of custom modules in the notebook, the add, split, and max modules. For example, the custom addition module: | Dans ce cas, il y a trois exemples de modules personnalisés dans le notebook, les modules add, split, et max. Par exemple, le module d’ajout personnalisé : |
If we have addition of two things and get an output, we need to overwrite the forward function like this. And when we go down to do back propagation, the gradients copied over both sides. So we overwrite the backward function by copying. | Si nous avons l’addition de deux choses et que nous obtenons un résultat, nous devons écraser la fonction forward comme ceci. Et lorsque nous rétropropagation, les gradients sont copiés sur les deux côtés. Nous écrasons donc la fonction backward en copiant. |
For split and max, see the code of how we overwrite forward and backward functions in the notebook. If we come from the same thing and Split, when go down doing gradients, we should add / sum them. For argmax, it selects the index of the highest thing, so the index of the highest should be 1 while others being 0. Remember, according to different custom modules, we need to overwrite its own forward pass and how they do gradients in backward function. | Pour les fonctions split et max, consultez le code pour la façon dont nous écrasons les fonctions forward et backward dans le notebook. Pour argmax, cela sélectionne l’indice de la chose la plus élevée. Ainsi l’indice de la plus élevée devrait être de 1 et 0 pour les autres. |
Week 6 | Semaine 6 |
We discussed three applications of convolutional neural networks. We started with digit recognition and the application to a 5-digit zip code recognition. In object detection, we talk about how to use multi-scale architecture in a face detection setting. Lastly, we saw how ConvNets are used in semantic segmentation tasks with concrete examples in a robotic vision system and object segmentation in an urban environment. | Nous discutons de trois applications des réseaux de neurones convolutifs. Nous commençons par la reconnaissance d’un code postal à 5 chiffres. En ce qui concerne la détection d’objets, nous abordons la manière d’utiliser une architecture multi-échelle dans le cadre de détection de visages. Enfin, nous voyons comment les ConvNets sont utilisés dans des tâches de segmentation sémantique avec des exemples concrets dans un système de vision robotique et la segmentation d’objets dans un environnement urbain. |
We examine Recurrent Neural Networks, their problems, and common techniques for mitigating these issues. We then review a variety of modules developed to resolve RNN model issues including Attention, GRUs (Gated Recurrent Unit), LSTMs (Long Short-Term Memory), and Seq2Seq. | Nous examinons les réseaux neuronaux récurrents (RNNs pour Recurrent Neural Networks), leurs problèmes et les techniques courantes permettant de les atténuer. Nous examinons ensuite divers modules développés pour résoudre les problèmes liés aux modèles RNNs, notamment l’Attention, les GRUs (Gated Recurrent Unit), les LSTMs (Long Short-Term Memory) et le Seq2Seq. |
We discussed architecture of Vanilla RNN and LSTM models and compared the performance between the two. LSTM inherits advantages of RNN, while improving RNN’s weaknesses by including a ‘memory cell’ to store information in memory for long periods of time. LSTM models significantly outperforms RNN models. | Nous discutons de l’architecture des modèles RNNs de base et des LSTMs et comparons les performances entre les deux. Les LSTMs héritent des avantages des RNNs, tout en améliorant leurs faiblesses en incluant une cellule mémoire afin de stocker les informations pendant de longues périodes. Les modèles LSTMs sont nettement plus performants que les modèles RNNs. |
Applications of Convolutional Network | Applications des ConvNets |
Zip Code Recognition | Reconnaissance des codes postaux |
In the previous lecture, we demonstrated that a convolutional network can recognize digits, however, the question remains, how does the model pick each digit and avoid perturbation on neighboring digits. The next step is to detect non/overlapping objects and use the general approach of Non-Maximum Suppression (NMS). Now, given the assumption that the input is a series of non-overlapping digits, the strategy is to train several convolutional networks and using either majority vote or picking the digits corresponding to the highest score generated by the convolutional network. | Dans les cours des semaines précédentes, nous avons démontré qu’un réseau convolutif peut reconnaître des chiffres. Cependant, la question demeure de savoir comment le modèle choisit chaque chiffre et évite les perturbations avec les chiffres voisins. L’étape suivante consiste à détecter les objets qui ne se chevauchent pas et à utiliser l’approche générale de la suppression non maximale (NMS en anglais pour Non-Maximum Suppression). Etant donné l’hypothèse que l’entrée est une série de chiffres ne se chevauchants pas, la stratégie consiste à entraîner plusieurs réseaux convolutifs et à utiliser soit un vote majoritaire, soit à choisir les chiffres correspondant au score le plus élevé généré par le réseau convolutif. |
Recognition with CNN | Reconnaissance avec les ConvNets |
Here we present the task of recognizing 5 non-overlapping zip codes. The system was not given any instructions on how to separate each digit but knows that is must predict 5 digits. The system (Figure 1) consists of 4 different sized convolutional networks, each producing one set of outputs. The output is represented in matrices. The four output matrices are from models with a different kernel width in the last layer. In each output, there are 10 rows, representing 10 categories from 0 to 9. The larger white square represents a higher score in that category. In these four output blocks, the horizontal sizes of the last kernel layers are 5, 4, 3 and 2 respectively. The size of the kernel decides the width of the model’s viewing window on the input, therefore each model is predicting digits based on different window sizes. The model then takes a majority vote and selects the category that corresponds to the highest score in that window. To extract useful information, one should keep in mind that not all combinations of characters are possible, therefore error correction leveraging input restrictions is useful to ensure the outputs are true zip codes. | Nous présentons ici la tâche consistant à reconnaître un code postal constitué de 5 chiffres ne se chevauchant pas. Le système n’a reçu aucune instruction sur la façon de séparer chaque chiffre, mais il sait qu’il doit prévoir 5 chiffres. Le système (figure 1) se compose de 4 ConvNets de taille différente, chacun produisant un ensemble de sorties. La sortie est représentée par des matrices. Les quatre matrices de sortie proviennent de modèles dont la dernière couche présente une largeur de noyau différente. Dans chaque sortie, il y a 10 lignes représentant les 10 chiffres de 0 à 9. Le plus grand carré blanc représente un score plus élevé dans cette catégorie. Dans ces quatre blocs de sortie, les tailles horizontales des dernières couches de noyaux sont respectivement de 5, 4, 3 et 2. La taille du noyau détermine la largeur de la fenêtre de visualisation du modèle en entrée, c’est pourquoi chaque modèle prédit des chiffres en fonction de différentes tailles de fenêtre. Le modèle effectue alors un vote majoritaire et sélectionne la catégorie qui correspond au score le plus élevé dans cette fenêtre. Pour extraire des informations utiles, il faut garder à l’esprit que toutes les combinaisons de caractères ne sont pas possibles. Ainsi une correction d’erreurs utilisant les restrictions d’entrée est utile afin de s’assurer que les sorties sont de véritables codes postaux. |
Now to impose the order of the characters. The trick is to utilize a shortest path algorithm. Since we are given ranges of possible characters and the total number of digits to predict, We can approach this problem by computing the minimum cost of producing digits and transitions between digit. The path has to be continuous from the lower left cell to the upper right cell on the graph, and the path is restricted to only contain movements from left to right and bottom to top. Note that if the same number is repeated next to each other, the algorithm should be able to distinguish there are repeated numbers instead of predicting a single digit. | Maintenant, il faut imposer l’ordre des caractères. L’astuce consiste à utiliser un algorithme de chemin le plus court. Comme on nous donne des plages de caractères possibles et le nombre total de chiffres à prévoir, nous pouvons aborder ce problème en calculant le coût minimum de production des chiffres et des transitions entre les chiffres. Le chemin doit être continu de la cellule inférieure gauche à la cellule supérieure droite du graphique. Il doit aussi contenir que des mouvements de gauche à droite et de bas en haut. De plus, si le même nombre est répété l’un à côté de l’autre, l’algorithme doit être capable de distinguer les nombres répétés au lieu de prédire un seul chiffre. |
Face detection | Détection des visages |
Convolutional neural networks perform well on detection tasks and face detection is no exception. To perform face detection we collect a dataset of images with faces and without faces, on which we train a convolutional net with a window size such as 30 × 30 pixels and ask the network to tell whether there is a face or not. Once trained, we apply the model to a new image and if there are faces roughly within a 30 × 30 pixel window, the convolutional net will light up the output at the corresponding locations. However, two problems exist. | Les ConvNets sont très performants dans les tâches de détection. La détection des visages ne fait pas exception. Pour effectuer la détection des visages, nous collectons un jeu de données d’images avec et sans visages sur lesquelles nous entraînons un ConvNet avec une taille de fenêtre de 30 × 30 pixels. Nous demandons alors au réseau de dire s’il y a un visage ou non. Une fois entraîné, nous appliquons le modèle à une nouvelle image et s’il y a des visages à peu près dans une fenêtre de 30 × 30 pixels, le ConvNet éclairera la sortie aux endroits correspondants. Cependant, deux problèmes se posent : |
False Positives: There are many different variations of non-face objects that may appear in a patch of an image. During the training stage, the model may not see all of them (i.e. a fully representative set of non-face patches). Therefore, the model may suffer from a lot of false positives at test time. For example, if the network has not been trained on images containing hands, it may detect faces based on skin tones and incorrectly classify patches of images containing hands as faces, thereby giving rise to false positives. | les faux positifs : il y a de nombreuses façons pour qu’un morceau d’image ne soit pas un visage. Pendant la phase d’entraînement, le modèle peut ne pas toutes les voir (c’est-à-dire que notre jeu de données n’est pas pleinement représentatif). Par conséquent, le modèle peut souffrir d’un grand nombre de faux positifs au moment du test. |
Different Face Size: Not all faces are 30 × 30 pixels, so faces of differing sizes may not be detected. One way to handle this issue is to generate multi-scale versions of the same image. The original detector will detect faces around 30 × 30 pixels. If applying a scale on the image of factor 2, the model will detect faces that were smaller in the original image since what was 30 × 30 is now 20 × 20 pixels roughly. To detect bigger faces, we can downsize the image. This process is inexpensive as half of the expense comes from processing the original non-scaled image. The sum of the expenses of all other networks combined is about the same as processing the original non-scaled image. The size of the network is the square of the size of the image on one side, so if you scale down the image by 2, the network you need to run is smaller by a factor of 2. So the overall cost is 1+1/2+1/4+1/8+1/16… which is 2. Performing a multi-scale model only doubles the computational cost. | la taille de visage différente : tous les visages ne sont pas de taille 30 × 30 pixels. Ainsi, les visages de tailles différentes peuvent ne pas être détectés. Une façon de traiter ce problème est de générer des versions multi-échelles de la même image. Le détecteur original détectera des visages d’environ 30 × 30 pixels. En appliquant une échelle sur l’image de facteur 2, le modèle détectera les visages plus petits dans l’image originale puisque ce qui était de taille 30 × 30 est maintenant d’environ 20 × 20 pixels. Pour détecter des visages plus grands, nous pouvons réduire la taille de l’image. Ce procédé est peu coûteux car la moitié des dépenses provient du traitement de l’image originale non réduite. La somme des dépenses de tous les autres réseaux combinés est à peu près la même que le traitement de l’image originale non mise à l’échelle. La taille du réseau est le carré de la taille de l’image d’un côté, donc si vous réduisez l’image par 2, le réseau que vous devez faire fonctionner est plus petit d’un facteur 2. Le coût global est donc de 1+1/2+1/4+1/8+1/16+…, ce qui donne 2. La réalisation d’un modèle multi-échelle ne fait donc que doubler le coût de calcul. |
A multi-scale face detection system | Un système de détection des visages à plusieurs échelles |
The maps shown in (Figure 3) indicate the scores of face detectors. This face detector recognizes faces that are 20 × 20 pixels in size. In fine-scale (Scale 3) there are many high scores but are not very definitive. When the scaling factor goes up (Scale 6), we see more clustered white regions. Those white regions represent detected faces. We then apply non-maximum suppression to get the final location of the face. | Les cartes présentées (figure 3) indiquent les scores des détecteurs de visages. Ce détecteur de visage reconnaît les visages qui ont une taille de 20 × 20 pixels. En échelle fine (Scale 3 dans la figure 3), il y a beaucoup de scores élevés mais pas définitifs. Lorsque le facteur d’échelle augmente (Scale 6), nous voyons davantage de régions blanches groupées. Ces régions blanches représentent les visages détectés. Nous appliquons alors une suppression non maximale pour obtenir l’emplacement final du visage. |
Non-maximum suppression | Suppression non maximale |
For each high-scoring region, there is probably a face underneath. If more faces are detected very close to the first, it means that only one should be considered correct and the rest are wrong. With non-maximum suppression, we take the highest-scoring of the overlapping bounding boxes and remove the others. The result will be a single bounding box at the optimum location. | Pour chaque région ayant un score élevé, il y a probablement un visage en dessous. Si plusieurs visages sont détectés très près du premier, cela signifie qu’un seul doit être considéré comme correct et que les autres sont faux. Dans le cas d’une suppression non maximale, nous prenons la zone la plus importante des cases de délimitation qui se chevauchent et nous supprimons les autres. Le résultat est alors une seule boîte englobante à l’emplacement optimal. |
Negative mining | Negative mining |
In the last section, we discussed how the model may run into a large number of false positives at test time as there are many ways for non-face objects to appear similar to a face. No training set will include all the possible non-face objects that look like faces. We can mitigate this problem through negative mining. In negative mining, we create a negative dataset of non-face patches which the model has (erroneously) detected as faces. The data is collected by running the model on inputs that are known to contain no faces. Then we retrain the detector using the negative dataset. We can repeat this process to increase the robustness of our model against false positives. | Nous avons vu comment un modèle peut se heurter à un grand nombre de faux positifs au moment de la phase de test car plusieurs objets peuvent ressembler à un visage de diverses façons. Aucun jeu d’entraînement ne peut contenir tous les objets qui ne sont pas des visages et ceux qui ressemblent à des visages. Nous pouvons atténuer ce problème grâce au negative mining (pêche à l’exemple négatif). Avec cette technique, nous exécutons notre modèle sur des entrées dont on sait qu’elles ne contiennent pas de visages. Tous les patchs sans visages mais que le modèle a détecté comme étant des visages sont alors ajoutés dans notre jeu de données d’exemples négatifs. Ensuite, nous recyclons le détecteur en utilisant le jeu de données négatives. Nous pouvons répéter ce processus pour augmenter la robustesse de notre modèle contre les faux positifs. |
Semantic segmentation | Segmentation sémantique |
Semantic segmentation is the task of assigning a category to every pixel in an input image. | La segmentation sémantique est la tâche qui consiste à attribuer une catégorie à chaque pixel d’une image d’entrée. |
CNN for Long Range Adaptive Robot Vision | ConvNets pour la vision adaptative à longue portée des robots |
In this project, the goal was to label regions from input images so that a robot can distinguish between roads and obstacles. In the figure, the green regions are areas the robot can drive on and the red regions are obstacles like tall grass. To train the network for this task, we took a patch from the image and manually label it traversable or not (green or red). We then train the convolutional network on the patches by asking it to predict the color of the patch. Once the system is sufficiently trained, it is applied to the entire image, labeling all the regions of the image as green or red. | Dans ce projet, l’objectif était d’étiqueter des régions à partir d’images d’entrée afin qu’un robot puisse distinguer les routes des obstacles. Dans la figure, les régions vertes sont les zones sur lesquelles le robot peut rouler et les régions rouges sont les obstacles comme les herbes hautes. Pour entraîner le réseau à cette tâche, nous avons pris un patch de l’image et l’avons étiqueté manuellement comme étant traversable ou non (vert ou rouge). Nous entraînons ensuite le réseau convolutif sur les patchs en lui demandant de prédire la couleur du patch. Une fois que le système est suffisamment entraîné, il est appliqué à l’ensemble de l’image, en étiquetant toutes les régions de l’image en vert ou en rouge. |
There were five categories for prediction: 1) super green, 2) green, 3) purple: obstacle foot line, 4) red obstacle 5) super red: definitely an obstacle. | Il y avait cinq catégories pour la prédiction : 1) super vert, 2) vert, 3) violet, 4) obstacle rouge, 5) super rouge : un obstacle certain. |
Stereo Labels (Figure 4, Column 2) Images are captured by the 4 cameras on the robot, which are grouped into 2 stereo vision pairs. Using the known distances between the stereo pair cameras, the positions of every pixel in 3D space are then estimated by measuring the relative distances between the pixels that appear in both the cameras in a stereo pair. This is the same process our brains use to estimate the distance of the objects that we see. Using the estimated position information, a plane is fit to the ground, and pixels are then labeled as green if they are near the ground and red if they are above it. | Étiquettes stéréo (Figure 4, colonne 2) : Les images sont captées par les 4 caméras du robot, qui sont regroupées en 2 paires de vision stéréo. En utilisant les distances connues entre les caméras des paires stéréoscopiques, les positions de chaque pixel dans l’espace 3D sont ensuite estimées en mesurant les distances relatives entre les pixels qui apparaissent dans les deux caméras d’une paire stéréoscopique. C’est le même processus que notre cerveau utilise pour estimer la distance des objets que nous voyons. En utilisant les informations de position estimées, un plan est ajusté au sol et les pixels sont alors étiquetés en vert s’ils sont proches du sol et en rouge s’ils sont au-dessus. |
Limitations & Motivation for ConvNet: The stereo vision only works up to 10 meters and driving a robot requires long-range vision. A ConvNet however, is capable of detecting objects at much greater distances, if trained correctly. | Limitations et motivation pour les ConvNets : La vision stéréo ne fonctionne que jusqu’à 10 mètres et la conduite d’un robot nécessite une vision à longue distance. Un ConvNet est cependant capable de détecter des objets à des distances beaucoup plus grandes, s’il est correctement entraîné. |
Served as Model Inputs: Important pre-processing includes building a scale-invariant pyramid of distance-normalized images (Figure 5). It is similar to what we have done earlier of this lecture when we tried to detect faces of multiple scales. | Servie comme entrée modèle : Un prétraitement important comprend la construction invariante au changement d’échelle d’images avec des distances normalisées (figure 5). Elle est similaire à ce que nous avons fait plus tôt dans ce cours lorsque nous avons essayé de détecter des visages de différentes tailles. |
Model Outputs (Figure 4, Column 3) | Sorties du modèle (figure 4, colonne 3) : |
The model outputs a label for every pixel in the image up to the horizon. These are classifier outputs of a multi-scale convolutional network. | Le modèle produit une étiquette pour chaque pixel de l’image jusqu’à l’horizon. Ce sont les sorties du classifieur d’un ConvNet multi-échelles. |
How the Model Becomes Adaptive: The robots have continuous access to the stereo labels, allowing the network to re-train, adapting to the new environment it’s in. Please note that only the last layer of the network would be re-trained. The previous layers are trained in the lab and fixed. | Comment le modèle devient adaptatif : |
System Performance | Performances du système : |
When trying to get to a GPS coordinate on the other side of a barrier, the robot “saw” the barrier from far away and planned a route that avoided it. This is thanks to the CNN detecting objects up 50-100m away. | En essayant d’obtenir une coordonnée GPS de l’autre côté d’une barrière, le robot a perçu cette barrière et a planifié un itinéraire qui l’a évitée. Ceci grâce à la détection d’objets situés à une distance de 50 à 100 m. |
Limitation | Limitation : |
Back in the 2000s, computation resources were restricted. The robot was able to process around 1 frame per second, which means it would not be able to detect a person that walks in its way for a whole second before being able to react. The solution for this limitation is a Low-Cost Visual Odometry model. It is not based on neural networks, has a vision of ~2.5m but reacts quickly. | Dans les années 2000, les ressources de calcul étaient limitées. Le robot était capable de traiter environ une image par seconde, ce qui signifie qu’il ne pouvait pas détecter une personne qui se trouvait sur son chemin pendant une seconde entière avant de pouvoir réagir. La solution à cette limitation est un modèle d’odométrie visuelle à faible coût. Il n’est pas basé sur les réseaux de neurones, a une vision d’environ 2,5m mais réagit rapidement. |
Scene Parsing and Labelling | Analyse et étiquetage des scènes |
In this task, the model outputs an object category (buildings, cars, sky, etc.) for every pixel. The architecture is also multi-scale (Figure 6). | Dans cette tâche, le modèle produit une catégorie d’objets (bâtiments, voitures, ciel, etc.) pour chaque pixel. L’architecture est également multi-échelle (figure 6). |
Notice that if we back project one output of the CNN onto the input, it corresponds to an input window of size 46×46 on the original image at the bottom of the Laplacian Pyramid. It means we are using the context of 46×46 pixels to decide the category of the central pixel. | Si nous rétropropageons une sortie du ConvNet sur l’entrée, cela correspond à une fenêtre d’entrée de taille 46×46 sur l’image originale au bas de la pyramide de Laplace. Cela signifie que nous utilisons le contexte des pixels 46×46 pour décider de la catégorie du pixel central. |
However, sometimes this context size is not enough to determine the category for larger objects. | Cependant, parfois, la taille de ce contexte n’est pas suffisante pour déterminer la catégorie des objets plus grands. |
The multiscale approach enables a wider vision by providing extra rescaled images as inputs. The steps are as follows: | L’approche multi-échelles permet une vision plus large en fournissant des images supplémentaires redimensionnées comme entrées : |
1. Take the same image, reduce it by the factor of 2 and a factor of 4, separately. | 1. Prendre la même image, la réduire séparément d’un facteur 2 et d’un facteur 4. |
2. These two extra rescaled images are fed to the same ConvNet (same weights, same kernels) and we get another two sets of Level 2 Features. | 2. Ces deux images supplémentaires redimensionnées sont envoyées au même ConvNet (mêmes poids, mêmes noyaux) et nous obtenons deux autres ensembles de caractéristiques de niveau 2. |
3. Upsample these features so that they have the same size as the Level 2 Features of the original image. | 3. Échantillonner ces caractéristiques de façon à ce qu’elles aient la même taille que les caractéristiques de niveau 2 de l’image originale. |
4. Stack the three sets of (upsampled) features together and feed them to a classifier. | 4. Empiler les trois ensembles de caractéristiques (suréchantillonnées) et envoyer-les à un classifieur. |
Now the largest effective size of content, which is from the 1/4 resized image, is 184×184 (46×4=184). | Maintenant, la plus grande taille effective du contenu, qui provient de l’image redimensionnée à 1/4, est de 184×184(46×4=184). |
Performance: With no post-processing and running frame-by-frame, the model runs very fast even on standard hardware. It has a rather small size of training data (2k~3k), but the results are still record-breaking. | Performance : sans post-traitement et en fonctionnant image par image, le modèle fonctionne très rapidement, même sur du matériel standard. Il a une taille assez réduite de données d’entraînement (2 000 à 3 000), mais les résultats sont toujours très performants. |
RNNs, GRUs, LSTMs, Attention, Seq2Seq, and Memory Networks | RNNs, GRUs, LSTMs, Attention, Seq2Seq, et Réseaux mémoire |
Deep Learning Architectures | Architectures de l’apprentissage profond |
In deep learning, there are different modules to realize different functions. Expertise in deep learning involves designing architectures to complete particular tasks. Similar to writing programs with algorithms to give instructions to a computer in earlier days, deep learning reduces a complex function into a graph of functional modules (possibly dynamic), the functions of which are finalized by learning. | En apprentissage profond, il existe différents modules pour réaliser différentes fonctions. L’expertise dans ce domaine implique la conception d’architectures pour réaliser des tâches particulières. L’apprentissage profond réduit une fonction complexe en un graphe de modules fonctionnels (éventuellement dynamiques), dont les fonctions sont finalisées par l’apprentissage. |
As with what we saw with convolutional networks, network architecture is important. | Comme pour ce que nous avons vu avec les réseaux convolutifs, l’architecture de réseau est importante. |
Recurrent Networks | Réseaux récurrents (RNNs) |
In a Convolutional Neural Network, the graph or interconnections between the modules cannot have loops. There exists at least a partial order among the modules such that the inputs are available when we compute the outputs. | Dans un ConvNet, le graphe ou les interconnexions entre les modules ne peuvent pas avoir de boucles. Il existe au moins un ordre partiel entre les modules, de sorte que les entrées sont disponibles lorsque nous calculons les sorties. |
As shown in Figure 1, there are loops in Recurrent Neural Networks. | Comme le montre la figure 1, il existe des boucles dans les réseaux neuronaux récurrents. |
x(t) : input that varies across time | x(t) : entrée qui varie dans le temps |
Enc(x(t)): encoder that generates a representation of input | Enc(x(t)) : encodeur qui génère une représentation de l’entrée |
h(t): a representation of the input | h(t) : une représentation de l’entrée |
w: trainable parameters | w : paramètres pouvant être entraînés |
z(t−1): previous hidden state, which is the output of the previous time step | z(t−1) : état caché précédent, qui est la sortie du pas de temps précédent |
z(t): current hidden state | z(t) : état caché actuel |
g: function that can be a complicated neural network; one of the inputs is z(t−1 which is the output of the previous time step | g : fonction qui peut être un réseau de neurones compliqué. L’une des entrées est z(t−1) qui est la sortie du pas de temps précédent |
Dec(z(t)): decoder that generates an output | Dec(z(t)) : décodeur qui génère une sortie |
Recurrent Networks: Unroll the loop | Réseaux récurrents dépliés |
Unroll the loop in time. The input is a sequence x1,x2,⋯ ,xT. | L’entrée est une séquence x1,x2,⋯ ,xT. |
In Figure 2, the input is x1,x2,x3. | Dans la figure 2, l’entrée est x1,x2,x3. |
At time t=0, the input x(0) is passed to the encoder and it generates the representation h(x(0))=Enc(x(0)) and then passes it to G to generate hidden state z(0)=G(h0,z’,w). At t=0, z’ in G can be initialized as 0 or randomly initialized. z(0) is passed to decoder to generate an output and also to the next time step. | Au temps t=0, l’entrée x(0) est passée à l’encodeur qui génère la représentation h(x(0))=Enc(x(0)). Puis il la passe à G pour générer l’état caché z(0)=G(h0,z’,w). À t=0, z’ dans G peut être initialisé comme valant 0 ou de manière aléatoire. z(0) est passé au décodeur pour générer une sortie mais aussi au pas de temps suivant. |
As there are no loops in this network, and we can implement backpropagation. | Comme il n’y a pas de boucles dans ce réseau nous pouvons mettre en œuvre la rétropropagation. |
Figure 2 shows a regular network with one particular characteristic: every block shares the same weights. Three encoders, decoders and G functions have same weights respectively across different time steps. | La figure 2 montre un réseau avec une caractéristique particulière : chaque bloc partage les mêmes poids. Trois encodeurs, décodeurs et fonctions G ont respectivement les mêmes poids sur différents pas de temps. |
BPTT: Backprop through time. Unfortunately, BPTT doesn’t work so well in the naive form of RNN. | Malheureusement, la rétropropagation à travers le temps (BPTT pour Backpropagation through time) ne fonctionne pas aussi bien dans la forme naïve du RNN. |
Problems with RNNs: | Il existe des problèmes avec les RNNs : |
Subsets and Splits