<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Maiya Rozhnova on Medium]]></title>
        <description><![CDATA[Stories by Maiya Rozhnova on Medium]]></description>
        <link>https://medium.com/@maiya.rozhnova.vicuesoft?source=rss-880cec06509a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*smXMgplV4inCW7Qs</url>
            <title>Stories by Maiya Rozhnova on Medium</title>
            <link>https://medium.com/@maiya.rozhnova.vicuesoft?source=rss-880cec06509a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 17:34:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@maiya.rozhnova.vicuesoft/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Changing the season in a photo using neural networks]]></title>
            <link>https://medium.com/deelvin-machine-learning/changing-the-season-in-a-photo-using-neural-networks-d628a192a20?source=rss-880cec06509a------2</link>
            <guid isPermaLink="false">https://medium.com/p/d628a192a20</guid>
            <category><![CDATA[cyclegan]]></category>
            <category><![CDATA[gans]]></category>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[deelvin]]></category>
            <category><![CDATA[neural-style-transfer]]></category>
            <dc:creator><![CDATA[Maiya Rozhnova]]></dc:creator>
            <pubDate>Tue, 23 Aug 2022 14:55:36 GMT</pubDate>
            <atom:updated>2022-08-23T14:55:36.256Z</atom:updated>
            <content:encoded><![CDATA[<p>How to change the season in a photo? During the COVID-19 pandemic, applications for changing background in a photo and video have become popular. Algorithms in such applications use neural networks that can highlight the boundaries of an object in a photo and then overlay the cut-out object on a new background. However, the result of the work of such algorithms is not always harmonious as you can get an image of a person in winter clothes sunbathing on the beach. To add to this, this method is not suitable if there are no objects in the foreground.</p><figure><img alt="An example of processing a photo with an autumn preset" src="https://cdn-images-1.medium.com/max/672/1*5agTjBSasfSW3XO4zLt1qQ.png" /><figcaption>Fig. 1. An example of processing a photo with an autumn preset</figcaption></figure><p>There exist ready-made sets of settings for processing photos — presets. For example, the autumn <a href="http://lyubimaya-co.com/autumn">preset</a> changes the colors in the photo from summer green to golden autumn (Fig. 1). The possibilities of such methods are limited as they can change only certain parameters — color, contrast, brightness, etc. However, neural networks can address tasks of different nature these days: from recognizing cats in a photo to creating a talking assistant. In this article, we will test the use of neural networks for changing the season in a photo.</p><h3>Image Style Transfer Using Convolutional Neural Networks</h3><p><a href="https://doi.org/10.1109/CVPR.2016.265">Neural Style Transfer</a> algorithm can be used to create an image with a chosen style. The goal of this algorithm is to find an image that best matches both the content of the first image (input) and the style of the second image (style). As a result, the location of objects in the original photo is preserved, while the colors and textures are taken from the image with a style. This method is based on a pre-trained neural network VGG-19 and its implementation on PyTorch can be viewed <a href="https://pytorch.org/tutorials/advanced/neural_style_tutorial.html">here</a>. For each pair of images, one can choose the optimal parameters of the loss function: ℒ<em>total</em>=αℒ<em>content+β</em>ℒ<em>style. </em>Changing the α and β parameters allows one to focus on either the content of the original image or the style. Content loss is defined as the square of the error between the features of the layer <em>l</em> of the original image <em>p</em> and the generated image <em>x</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*WmzgErJh9XduQ2AxeXy7uQ.png" /></figure><p>Style loss is defined somewhat differently. Style image texture information is calculated as image feature correlation determined by Gram matrix:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/294/1*miUJy_F9eXDrLXWkQAtkzQ.png" /></figure><p>To create an image with a specified style, it is necessary to minimize the root-mean-square distance between the elements of the Gram matrices of the original and generated images:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/390/1*mAK369KFvYNnjw0UdIgCNA.png" /></figure><p>where</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/548/1*ttgbfCBvdBUEzeDXrN7B1w.png" /></figure><p>and <em>ωl</em> are weight coefficients for each layer.</p><p>This method of style transfer gives interesting and unique results when works of art are used as style images: paintings by Vincent van Gogh, Pablo Picasso, Edvard Munch and other famous artists. But how about using photos of a different season instead? Let’s try to change a winter landscape to a summer one. Figure 2 shows an example of how this method works, when the input image is my winter photo, the style image is a summer landscape, and the output is an image in the colors of the style image. This example clearly demonstrates that the original image gets completely recolored: the network does not pay attention to whether there is a person in the photo or not.</p><figure><img alt="Example of Image Style Transfer algorithm with different style images" src="https://cdn-images-1.medium.com/max/1024/1*X51FfMmnDuTRDzky_tnFbQ.png" /><figcaption>Fig. 2. Example of Image Style Transfer algorithm with different style images</figcaption></figure><p>If we take as an input an image of a different style which is similar in content to the original image, in the output image we see an attempt to repaint the snow in a different color (Fig. 3). By changing the parameters of the loss function we might get a less white background, but in any case, this method cannot select objects in the original image that need to be colored in a different color. Also, the content loss function will not allow removing or replacing any objects in the image, for example, changing a winter hat to a cap.</p><figure><img alt="Example of Image Style Transfer algorithm with similar style images" src="https://cdn-images-1.medium.com/max/1024/1*HAgL8pyL1A1RsfNPffdysA.png" /><figcaption>Fig. 3. Example of Image Style Transfer algorithm with similar style images</figcaption></figure><h3>Image Style Transfer Using GAN (Generative Adversarial Networks)</h3><p>The Generative Adversarial Network (<a href="https://arxiv.org/abs/1406.2661">GAN</a>) can be used to create artificial images similar to the training dataset. GAN includes a generator (<em>G</em>) of new images and a discriminator (classifier) (<em>D</em>) that determines whether the image is real or fake (Fig. 4).</p><figure><img alt="GAN structure" src="https://cdn-images-1.medium.com/max/1024/1*LPzuX5fE4iIrf3DMEN67Uw.jpeg" /><figcaption>Fig. 4. GAN structure</figcaption></figure><p>The goal of training the generator is to minimize the function log(1−<em>D</em>(<em>G</em>(<em>z</em>))), and the goal of training the discriminator is to increase the probability of assigning the correct class to both real images and artificial images received from the generator. Therefore, the objective learning function is a minimax game of two players: a generator and a discriminator.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GQkt5LH4k75aZQ9Rrm9XXA.png" /></figure><p>The <a href="https://arxiv.org/abs/1611.07004">image-to-image translation</a> task is the task of converting a given representation of a scene into another one, for example, a gray image into a color image, an apple into an orange, or, what is relevant for our topic, the transformation of winter into summer and vice versa. In the following section we will consider several examples of GAN-based networks that solve the problem of changing the season in a photo.</p><h4>CycleGAN</h4><figure><img alt="An example of the work of CycleGAN from the authors of the model (upper row: winter -&gt; summer, bottom row: summer -&gt; winter)" src="https://cdn-images-1.medium.com/max/1024/1*nm6dPI8YhNO5yjmj75atAg.png" /><figcaption>Fig. 5. An example of the work of CycleGAN from the authors of the model (upper row: winter → summer, bottom row: summer → winter)</figcaption></figure><p>Pre-trained models are available for <a href="https://arxiv.org/abs/1703.10593">CycleGAN</a> for the following transformations: summer ↔ winter (Fig. 5), zebra ↔ horse, apple ↔ orange, Monet painting ↔ photo and others. CycleGAN is based on the “<a href="https://arxiv.org/abs/1611.07004">pix2pix</a>”, concept, which uses a conditional generative adversarial network. However, while pix2pix uses paired data for training, CycleGAN addresses the task of unpaired image-to-image translation since not every task has paired images in the training sample. In the context of the season change task, training CycleGAN does not require winter and summer images of the same scene and it is enough to have a set of summer and winter images with different scenes (Fig. 6). CycleGAN learns to extract features from one set of images (summer) and select a way of translating them into another set of images (winter).</p><figure><img alt="An example of a paired and unpaired dataset" src="https://cdn-images-1.medium.com/max/868/1*elDuw5o9FcUMNRtbsJpmBQ.png" /><figcaption>Fig. 6. An example of a paired and unpaired dataset</figcaption></figure><p>CycleGAN is called so because the training process minimizes “cycle consistency loss”. If <em>X</em> is a set of summer images, <em>Y</em> is a set of winter images, <em>G</em> is a transformation from summer to winter, <em>F </em>is an inverse transformation from winter to summer, then the loss for the task under consideration is described as follows (Fig. 7): we take image <em>x</em> from <em>X</em>, apply the transformation <em>G</em>, get some result and apply the inverse transformation <em>F</em> to it, then as a result of the double transformation (summer → winter → summer) we should get an element similar to the original <em>x</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ktVOtf2UF5po9oaIN838Xg.png" /><figcaption>Fig. 7. a) scheme of interaction of generators G, F and discriminators DX, DY. b) cycle-consistency loss structure for images from set X, c) cycle-consistency loss structure for images from set Y</figcaption></figure><p>The difference between <em>x</em> and <em>F</em>(<em>G</em>(<em>x</em>)), as well as the similar difference between <em>y</em> and <em>G</em>(<em>F</em>(<em>y</em>)) is the required loss:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/707/1*yULW40ga-dwQDDyB13VPmg.png" /></figure><p>Also, the training goal is to minimize the losses of the two discriminators <em>DX</em> and <em>DY</em>, which classify the result of the transformations <em>F</em> and <em>G</em> respectively:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*7QCiMMrAIthKgMJrpg2bkw.png" /></figure><p>So we get the target loss:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*7I1DVil6eQ1IVjB1zjNpFQ.png" /></figure><h4>Contrastive Learning for Unpaired Image-to-Image Translation</h4><p>The authors did not stop at CycleGAN and proposed a faster and less memory-intensive <a href="https://arxiv.org/abs/2007.15651">model</a>. The training time of this model is reduced because it is based on mapping in one direction only, so no resources are wasted on an inverse generator and discriminator. Another advantage of the model is the ability to train on a set of images consisting of a single image.</p><p>In this case, the task of unpaired image-to-image translation is solved by using patchwise contrastive learning (Fig. 8) and the <a href="https://arxiv.org/abs/1807.03748">InfoNCE</a> loss function which connects the corresponding patches of a pair of images (horse head and zebra head in Fig. 8) and separates them from negative patches (yellow patches in Fig. 8). This is required to generate a realistic image, and the patches in the input and output images to have a common match (parts or shapes of the object) while remaining invariant to colors or textures.</p><figure><img alt="Patchwise contrastive learning structure" src="https://cdn-images-1.medium.com/max/1024/1*sQ4EzkZmllH9XKIMpKvVIQ.png" /><figcaption>Fig. 8. Patchwise contrastive learning structure</figcaption></figure><p>The PatchNCE loss function can be described as follows. In the process of training, features are extracted from a pair of images <em>x</em> and <em>y</em> (Fig. 9). In the second image, a query patch is selected and compared with the corresponding patch in the first image. Also, <em>N</em> patches of negatives are selected in the first image and the task of classifying the query patch in the second image on the set of <em>N</em> + 1 (<em>N</em> negatives + positive patch) elements is performed. As a result, the zebra head patch should be more related to the horse’s head than to the rest of the patches in the first photo.</p><figure><img alt="Patchwise Contrastive Loss description" src="https://cdn-images-1.medium.com/max/1024/1*TxH9Ph8uSUVJaQHEEgVBVA.png" /><figcaption>Fig. 9. Patchwise Contrastive Loss description</figcaption></figure><p>The final loss function consists of a combination of the loss function for GAN and PatchNCE losses for two sets of images <em>X</em> and <em>Y</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A9Rt6pOmuBEU2pSW1j-6RQ.png" /></figure><p>The values <em>λX</em> = 1, <em>λY</em> = 1 correspond to mutual learning with identity loss. This combination of parameters is called Contrastive Unpaired Translation (CUT) and demonstrates good performance. Learning without identity loss (<em>λX</em> = 10, <em>λY</em> = 0) is called FastCUT and it can be considered a simpler and faster version of CycleGAN. This method also allows one to reproduce the texture of a given photo while maintaining the structure of the input image, which is similar to the Neural Style Transfer method described at the beginning of the article.</p><h4>MSGAN: Generative Adversarial Networks for Image Seasonal Style Transfer</h4><p>The task of changing the season is non-trivial and is complicated by the fact that it involves more than changing the main palette of colors from green (summer) to white (winter). It also requires adding/removing certain objects or changing their shape without spoiling objects that should not be changed in any way. For example, a snowman should not be present in the summer image, but the house should be the same color in summer and winter images.</p><p><a href="https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9107081">MSGAN</a> model was proposed to address these tasks and it is capable of generating 4 seasons for the input image. For training, a set of images with different seasons is used, paired data are not required. The MSGAN architecture consists of two generators and three discriminators and is shown in Fig. 10.</p><figure><img alt="MSGAN Architecture" src="https://cdn-images-1.medium.com/max/811/1*hXNZDAkYXxIiWCOWBXXwSQ.png" /><figcaption>Fig. 10. MSGAN Architecture</figcaption></figure><p>First, the input image is converted from RGB to grayscale. So, to simplify the discriminator the season of the original picture is not taken into account. Then the generator transforms the original image into images with seasonal styles and for this it learns the global features of the image. The generator consists of an encoder and a decoder, symmetrical in structure, and seven layers of ResNet blocks. Residual blocks retain the size and shape of the previous network layer and affect the next layer, which can improve network performance and prevent gradient decay during training.</p><p>MSGAN uses 2 types of discriminators. One of them is binary, it answers the question “is the image real or artificial”, just like in the standard GAN structure described above. The second type of discriminator (<em>Ds</em>) determines the season of the generated image — it is AlexNet classifier with Softmax activation function in the last layer. The style loss function <em>Lstyle</em> is defined as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/868/1*6p4zj64hTiCF_zA_AZf6Rw.png" /></figure><p>If the season is the same, <em>DS</em> outputs 0, otherwise <em>DS</em> outputs 1.</p><p>The task of the generator is to create an image <em>G</em>(<em>x</em>|<em>c</em>) from an input image <em>x</em> given season <em>c</em> and to ‘fool’ the seasonal discriminator <em>Ds</em>. Therefore, the input image is transformed from one style to another based on the auxiliary information <em>c</em> and the CGAN (Conditional GAN) loss is described as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/866/1*klbN35qQMiMfSFNp_Hbo2w.png" /></figure><p>In this case, instead of the negative logarithmic loss function, the least square loss function is used.</p><p>MSGAN, like CycleGAN, also uses cycle consistency loss (<em>Lcyc</em>) to match the input image <em>x</em> and the result <em>G</em>(<em>F</em>(<em>x</em>)) when using double season transformation.</p><p>When changing the season, the structural similarity of the content of the original and generated image should be preserved as much as possible. The authors use SSIM loss with a filtering window size of 13:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/630/1*jqyRiOXVJAVQyp1DcVAWkA.png" /></figure><p>where <em>N</em> is the number of pixels <em>p</em> in windows <em>x</em> and <em>G</em>(<em>x</em>).</p><p>Also, when the season changes, the color scheme of the image changes significantly. Instead of the RGB space for the loss (with a sliding window of 13*13), the <em>H</em> (hue) component, which is more understandable for human perception, is taken from the HSV color space.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*CA4kUe-d3UyxiVs2HMWBbg.png" /></figure><p>In the work under consideration, the authors took into account that when changing the season, it is not necessary to use the same transformation operator for all image regions. The image is segmented according to <a href="https://doi.org/10.1109/TPAMI.2011.146">Hou et al.</a> algorithm and for important segments the following loss is used:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/1*qbPZNmUMAPKgD7T7ZO5OZg.png" /></figure><p>and for other segments, loss with different weights is used:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*46AerNZUyw2lq9jX4cNsWg.png" /></figure><p>The result of the algorithm with the selection of important segments is shown in Fig. 11a and without using information on importance in Fig. 11b. In the second image, along with the tree and grass, the bench turned green.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/941/1*h2ZLEMGi4BLbEeLyv0lDyw.png" /><figcaption>Fig. 11. Image generated a) with the selection of important segments b) without the selection of important segments</figcaption></figure><p>The authors also compared the performance of MSGAN with the results of other networks (Fig. 12). Among shortcomings, it was noted that CycleGAN generates only one style, not 4; CGAN produces noisy images; and UMGAN retains the structure of the image, but the hue of the whole image is shifted to the main color of the season (especially when looking at the color of the sky) because UMGAN was originally used in the task of conveying the style of an underwater image.</p><figure><img alt="Comparison of the results of MSGAN, CGAN, CycleGAN и UMGAN" src="https://cdn-images-1.medium.com/max/1024/1*58AjLN-nZ1Eqricp2jPhyQ.png" /><figcaption>Fig. 12. Comparison of the results of MSGAN, CGAN, CycleGAN and UMGAN</figcaption></figure><h4>CycleGAN example</h4><p>Training GANs is a rather time- and resource-consuming process, so to demonstrate the operation of this type of networks, we will use <a href="https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix">PyTorch realization CycleGAN</a> and the pre-trained summer2winter_yosemite.pth and winter2summer_yosemite.pth models (these and other available weights can be downloaded using <a href="https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/scripts/download_cyclegan_model.sh">script</a> from the same github). The results of CycleGAN for transforming summer into winter are shown in Fig.13. Fake winter images are either gray or reddish, although there are harmonious results in some landscapes. Also, the network does not remove objects that cannot be present in a winter photo (flowers, tree leaves).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*fx1r7Ff6GsxnqMntV0PLEg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/865/1*8LJygBTAXvVkFxrmptzS8Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OR2w4XopNuyWsANIO3UQeg.png" /><figcaption>Fig. 13 An example of CycleGAN operation transforming summer → winter</figcaption></figure><p>Fig. 14 shows the results of the reverse transformation from winter to summer. As an output, we again get red shades and there is too much white snow left. We also see repainted objects that should have remained the same color (red berries, a person’s face).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/872/1*240P1qz55CLoT8tFB3XANw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/862/1*PtwI5CwaEr4vELcs4HOEqw.png" /><figcaption>Fig. 14 An example of CycleGAN operation transforming winter → summer</figcaption></figure><p>To run CycleGAN on my images, I used <a href="https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/CycleGAN.ipynb">this</a> instruction and ran the test.py script with the following parameters:</p><pre>python3 test.py --dataroot datasets/summer2winter_yosemite --name summer2winter_pretrained --model cycle_gan --results_dir results_cycle_gan --no_dropout</pre><p>It is important to create one’s test dataset in advance by placing images in the folders test_A and test_B (A — summer, B — winter), and also download pre-trained models to the checkpoints folder.</p><p>After trying several approaches to solving the task of changing the season in a photo, the following conclusions can be drawn. The Convolutional Neural Network-based model is less efficient and needs 2 images per input. The MSGAN model is capable of recoloring individual sections of a photo and generating 4 seasons photos for one input image. CycleGAN performance is poor for photos with a person because it changes the color of the entire photo, however with some landscapes you can still get acceptable quality.</p><p>I also invite you to read other articles in our <a href="https://medium.com/deelvin-machine-learning">Deelvin Machine Learning Blog</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d628a192a20" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deelvin-machine-learning/changing-the-season-in-a-photo-using-neural-networks-d628a192a20">Changing the season in a photo using neural networks</a> was originally published in <a href="https://medium.com/deelvin-machine-learning">Deelvin Machine Learning</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Impact of dataset errors on model accuracy]]></title>
            <link>https://medium.com/deelvin-machine-learning/impact-of-dataset-errors-on-model-accuracy-723fef5e0b28?source=rss-880cec06509a------2</link>
            <guid isPermaLink="false">https://medium.com/p/723fef5e0b28</guid>
            <category><![CDATA[convolutional-neural-net]]></category>
            <category><![CDATA[image-classification]]></category>
            <category><![CDATA[mnist]]></category>
            <category><![CDATA[deelvin]]></category>
            <dc:creator><![CDATA[Maiya Rozhnova]]></dc:creator>
            <pubDate>Tue, 27 Jul 2021 15:02:34 GMT</pubDate>
            <atom:updated>2021-07-27T15:02:34.642Z</atom:updated>
            <content:encoded><![CDATA[<p>Working with data is essential for ML researchers because the resulting model depends on the choice of data and the training strategy. Consequently, each researcher faces the following questions:</p><ul><li>How much data is needed to obtain high accuracy?</li><li>Can a network learn from erroneous data?</li><li>If so, what is the maximum error rate that can be present in the data for the accuracy of the network to remain high?</li></ul><figure><img alt="computer image with handwritten and typed digits" src="https://cdn-images-1.medium.com/max/1024/1*ara51n8cc8SiP0ns8pYwfQ.jpeg" /></figure><p>In this article, we will try to find answer to these questions by training a network on datasets with a different number of samples and a different number of errors.</p><p>We used MNIST dataset which is used for classifying handwritten digits. MNIST contains 60,000 elements in the train sample and 10,000 elements in the test sample. Figure 1 demonstrates examples of images from the dataset, these are single-channel images of 28*28 pixels size.</p><figure><img alt="handwritten digits from MNIST dataset" src="https://cdn-images-1.medium.com/max/557/1*VCly35WjU8yvwgRf6zpONQ.png" /><figcaption>Fig. 1 MNIST dataset samples</figcaption></figure><p>The distribution by class in the train sample is as follows:</p><p>‘0’ — 5923, ‘1’ — 6742, ‘2’ — 5958, ‘3‘ — 6131, ‘4’ — 5842,</p><p>‘5’ — 5421, ‘6’ — 5918, ‘7’ — 6265, ‘8’ — 5851, ‘9’ — 5949</p><p>Network description:</p><p>We created a convolutional neural network from 2 convolutional layers and one fully connected one using PyTorch (torch.nn.Module). We used the activation function Relu and MaxPooling.</p><pre>conv1 = nn.Sequential(nn.Conv2d(in_channels=1,</pre><pre>                                out_channels=16,<br>                                <br>                                kernel_size=5,</pre><pre>                                stride=1,</pre><pre>                                padding=2),</pre><pre>                      nn.ReLU(),</pre><pre>                      nn.MaxPool2d(kernel_size=2))</pre><pre>conv2 = nn.Sequential(nn.Conv2d(16, 32, 5, 1, 2),</pre><pre>                      nn.ReLU(),</pre><pre>                      nn.MaxPool2d(2))</pre><pre>out = nn.Linear(32 * 7 * 7, 10)</pre><p>To find out how much data is required for high accuracy of the network we conducted the following experiment. N elements of each class were randomly selected from the whole dataset (60,000 samples), the size of the new dataset = N * 10 classes. For each mini-dataset, a network was trained (10 epochs) and the accuracy was obtained on the test sample (Fig. 2, 3). Each point on the graph corresponds to the obtained accuracy on the test sample when training on each of these mini-datasets.</p><figure><img alt="graph" src="https://cdn-images-1.medium.com/max/640/1*qBhymEf_bBx_WGK7lOy0tA.png" /><figcaption>Fig. 2 Dependence of accuracy of the test sample (10,000) on the number of elements in the class (from 1 to 3500 elements in the class)</figcaption></figure><p>The prediction accuracy of the test sample equals 99% when the network is trained on MNIST dataset. When training the network on mini-datasets with more than 100 elements in each class (or 1000 elements in the dataset), we get a test accuracy of more than 90% (Fig. 2, 3). In this case, the larger the training sample is, the more accurate the model predictions are. If the dataset contains more than 250 elements of each class, the accuracy reaches 95%. Using only a third of the original dataset, without any network complications, we nearly reach the accuracy on the original dataset, i.e. 2000 elements in each class give the accuracy of 98%. In Fig. 2 the horizontal step equals 100 (or +10 elements for each class at each step), in Fig. 3 the step is 10 (or +1 element to each class at each step).</p><figure><img alt="graph" src="https://cdn-images-1.medium.com/max/640/1*1DJUbTjyawpyCdbbXZ1gEA.png" /><figcaption>Fig. 3 Dependence of accuracy of the test sample (10,000) on the number of elements in the class (from 1 to 200 elements in the class)</figcaption></figure><p>When working with a large amount of data in datasets, errors may appear due to incorrect automatic processing or due to human error during manual tagging. It is intuitively clear that when erroneous data is present in the dataset, the accuracy of the network prediction is expected to fall. Let’s check how the accuracy will drop when training the considered network on datasets that contain errors.</p><p>MNIST dataset was corrupted in a certain way. In each class, a correct element was selected and the wrong random class value was assigned to it (out of the remaining 9 classes), thus in each class there was the same number of errors. For example, the picture shows “1”, and we change the name of the class to “5”. Then we ‘spoil’ 10 more elements of the dataset. Continuing in this way, we increase the number of errors in the dataset.</p><p>The training results are shown in Fig. 4. Each point on the graph corresponds to one training on the dataset with errors, while the horizontal indicates the number of errors in each class of the dataset, and the vertical indicates the accuracy on the train and the best accuracy on the test sample at 10 and 20 epochs.</p><figure><img alt="graph" src="https://cdn-images-1.medium.com/max/640/1*Ms7S_nMZFfzyhmR42izi8A.png" /><figcaption>Fig. 4. Dependence of accuracy of the test sample (10,000) on the number of erroneous elements in each class (5400 maximum), training — 20 epochs</figcaption></figure><p>We found that on this dataset that the network can be error resistant. If there are 1000 errors in each class (15–18% of errors in each class), the accuracy on the test sample is more than 92% (Fig. 4). When the number of incorrectly tagged elements of the dataset is increased, the accuracy on the test and train sample gradually decreases. At the same time, having 2000 errors in each class (i.e. a third of the dataset with errors), we still get high accuracy on the test sample — 90% (Fig. 4, green curve).</p><p>As shown above in Fig. 2 and 3, the network was trained on a dataset of 1000 images with the test set accuracy of 90%. Possibly, this explains why, even if there are 1000 or 2000 errors in each class of the dataset, the network had enough other correct elements for training.</p><p>It is worth noting that with an increase in the number of errors in the dataset, the accuracy on the train sample decreases faster than the accuracy on the test sample. This means that the network was able to learn from the corrupted data and was not just memorizing the training set. At the same time, more complex networks with a large number of parameters are able to memorize a training set with random (incorrect) labels, giving out almost 100% accuracy during training, but low accuracy on the test set. Such a case is described, for example, <a href="https://arxiv.org/pdf/1611.03530.pdf">here</a>.</p><p>Thus, we demonstrated that a convolutional neural network is capable of learning on datasets with errors, but its prediction accuracy decreases.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=723fef5e0b28" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deelvin-machine-learning/impact-of-dataset-errors-on-model-accuracy-723fef5e0b28">Impact of dataset errors on model accuracy</a> was originally published in <a href="https://medium.com/deelvin-machine-learning">Deelvin Machine Learning</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Impact of artifacts on the accuracy of network prediction.]]></title>
            <link>https://medium.com/deelvin-machine-learning/the-impact-of-artifacts-on-the-accuracy-of-network-prediction-f29c5ddf3eb?source=rss-880cec06509a------2</link>
            <guid isPermaLink="false">https://medium.com/p/f29c5ddf3eb</guid>
            <category><![CDATA[deelvin]]></category>
            <category><![CDATA[object-classification]]></category>
            <category><![CDATA[data-augmentation]]></category>
            <category><![CDATA[resnet]]></category>
            <category><![CDATA[inception]]></category>
            <dc:creator><![CDATA[Maiya Rozhnova]]></dc:creator>
            <pubDate>Tue, 06 Oct 2020 13:02:12 GMT</pubDate>
            <atom:updated>2020-10-06T13:02:12.965Z</atom:updated>
            <content:encoded><![CDATA[<p>Application of neural networks is ubiquitous nowadays in addressing various tasks. There are pre-trained networks that are capable of instantly identifying the primary object in a picture. Also, a network pre-trained on a large dataset could be used to tackle other related problems. This is often referred to as <a href="https://en.wikipedia.org/wiki/Transfer_learning">transfer learning</a>. In particular, transfer learning is the application of knowledge extracted by a neural network while solving other problems.</p><p>While solving real-life problems, we can often transfer data to the network that contain minor artifacts. Then the network will yield wrong answer, even though the correct answer appears to be obvious. For example, when transcoding a video stream, we can get blockiness artifacts, or when photographing, we can get a blurry picture with a blur artifact.</p><p>In this article, I will test how image quality affects the prediction accuracy of the neural network. What happens if the network receives an image with a small amount of artifacts as input?</p><p>By way of illustration, I will consider three pre-trained networks: InceptionV3, MobileNet and ResNet50 with ImageNet weights. The Keras framework will be used and some characteristics of these networks (Fig. 1) are given on the website <a href="https://keras.io/api/applications/">https://keras.io/api/applications/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UMIuyLPjMFsLINuiPjJahQ.png" /><figcaption>Figure 1: Characteristics of the networks used</figcaption></figure><p>I will test if the network is able to distinguish which animal is shown in the picture if I input a corrupted image. Let the original image (Fig. 2) contain an elephant with the image dimensions 1280x852.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9RhUNqj1cta9ruwTCjz-Qg.jpeg" /><figcaption>Figure 2: Original image</figcaption></figure><p>The image is corrupted in different ways: Gaussian blur, adding white noise, as well as the blocking effect that can occur when the image is compressed by codecs (including video codecs). Each artifact type is superimposed in 10 degrees, from weak to strong. Fig. 3 shows blurred images, the difference is in the size of the blur kernel. For example, in Fig. 3 (1), a square core with a side of 11 pixels is used — minor changes, in Fig. 3 (2) — blur with a core with a side of 67 pixels, Fig. 3 (3) — 137 px. I use the blur filter from OpenCV.</p><pre>import cv2</pre><pre>kernel = 11<br>blured_img = cv2.GaussianBlur(original_img, (kernel, kernel), 0)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y2AtmEob-DyOnDQ626u1zg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LU7c92M1_regLaJXjmUzfA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*23QkWhKgv1Zg7ZZFv-CHow.png" /><figcaption>Figure 3: Blurred images with 3 levels of distortion (level = 0.1, 0.5, 1.0)</figcaption></figure><p>In the second case, white noise is added using the <a href="https://scikit-image.org/docs/dev/api/skimage.util.html#skimage.util.random_noise">skimage.utils module</a>; here different values are responsible for the strength of the noise standard deviation of the Gaussian distribution. An example of obtaining a noisy image with a standard deviation of 0.1 is demonstrated below. Fig. 4 (1) presents the result. In fig. 4 (2 and 3), the standard deviation takes the values 0.5 and 1.0, respectively.</p><pre>from skimage.util import random_noise<br>from skimage import img_as_ubyte</pre><pre>st_dev = 0.1<br>noise = random_noise(orig_img, mode=’gaussian’, var=st_dev ** 2, seed=44, clip=True)<br>noisy_img = img_as_ubyte(noise)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OMQ4QlAzZSOTXOwS-Pwl3A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PPTSWsYv8kHaFmR95X14nw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bApCCdKimr52j6oxLO_xHg.png" /><figcaption>Figure 4: Noisy images with 3 levels of distortion (level = 0.1, 0.5, 1.0)</figcaption></figure><p>The third type is a frame from a video compressed with the H.264 codec, with a varied Constant Rate Factor (CRF) (Fig. 5). The experiment yields 10 corrupted pictures with CRF from 28 to 51, where CRF = 51 corresponds to the worst quality and strongest compression (Fig. 5 (3)). A small level of blockiness is shown in Fig. 5 (1) with CRF = 28 and Fig. 5 (2), where CRF = 38 was used. Such images can be obtained using the <a href="https://trac.ffmpeg.org/wiki/Encode/H.264">ffmpeg</a> video utility. The commands are given below.</p><pre>cmd_encode = ‘ffmpeg -y -framerate 1 -i concat:elephant.jpg -vcodec h264 -r 1 -g 1 -x264-params nal-hrd=cbr -x264opts no-deblock -crf 51 out.avi’</pre><pre>cmd_decode = ‘ffmpeg -y -i out.avi -r 1/1 block.png’</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9_mxwurYlpMrba_NXK2hIg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mE8OR3tcI_PDHwD_jGAtqg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DJhoiTxKX_Agm0HoVH5jFQ.png" /><figcaption>Figure 5: Blocking image with 3 levels of distortion (level = 0.1, 0.5, 1.0)</figcaption></figure><p>So we have the original image. We get 30 corrupted ones: 3 artifacts, 10 levels each. For the original image, all the networks in question predict that the image depicts the “African elephant” class. Let’s check how the score of the African elephant class will change if the network receives a corrupted picture as an input.</p><p>The results are shown below in the form of graphs. Fig. 6 shows graphs depicting how the score of the tracked class changes with the level of image corruption. The blue dotted line is the score of the original image. Level of distortion — some relative value, varies from 0 to one, here 0 is the score of the original image, then there are scores of 10 damaged images, each line for one type of distortion (blur, noise and blocking) and the level of distortion 1 corresponds to the worst image. Figures 7 and 8 present similar results for MobileNet and ResNet50, respectively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*I3a9n4QoRfK-AGOX26M83w.png" /><figcaption>Figure 6: Dependence of the “African elephant” score on the level of distortion for the InceptionV3 network</figcaption></figure><p>I will now demonstrate what the top-5 predictions of the InceptionV3 network look like for the original and some damaged pictures.</p><blockquote><strong>InceptionV3 top-5</strong></blockquote><blockquote><strong>original image</strong>: (<strong>‘African_elephant’, 0.8060587</strong>)(‘tusker’, 0.14671499), (‘Indian_elephant’, 0.003548297), (‘Komodo_dragon’, 0.00044263015), (‘mushroom’, 0.00026282403)</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*uCf7axOAityv0LZj3ccSHg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*U4LM2guNlcKc89M5jaxuRg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*kQb3gpw0lC8ixzk2jSy_Pw.png" /><figcaption>The top-5 predictions of the InceptionV3 network for some damaged pictures</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*xm4yGK1-zh8drHVl81ZYVQ.png" /><figcaption>Figure 7: Dependence of the “African elephant” score on the level of distortion for the MobileNet network</figcaption></figure><p>Interestingly, some artifacts increase the score. In particular, these are blur and noise with the level 0.1 (weak blur and low noise) for InceptionV3 and MobileNet networks (Fig. 6, 7).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*fh-Gc6ARwE6fUwkOOBtaDA.png" /><figcaption>Figure 8: Dependence of the “African elephant” score on the level of distortion for the ResNet50 network</figcaption></figure><p>Also, for all considered networks, there is a certain value of the level of distortion of the blockiness line, at which an increase in the score is observed.</p><p><strong>Experiment 1. </strong>Is it a coincidence that weak noise and blur increases the score? Let’s run the following experiment. Let’s take 1500 elephant images from the <a href="https://cocodataset.org/">COCO dataset</a>. I will spoil each image with weak noise (deviation = 0.1), add blur (area of ​​blur kernel / image area = 0.00015) and take blockiness with the level of 0.5 (CRF = 38). For each image, each network and each of the 3 artifacts, the difference in the scores of the ‘African_elephant’ class between the damaged and the original image is obtained. The table below shows average values ​​of the differences.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/927/1*7NxUed6g6XPaQRcODAmQ-g.png" /><figcaption>Mean difference in the scores of the ‘African_elephant’ class between the damaged and the original image</figcaption></figure><p><strong>Conclusion 1.</strong> It can be seen that the blur and blockiness for all 3 networks tend to decrease the score (i.e., on average, <em>Score(‘African_elephant’) distorted — Score(‘African_elephant’)original &lt;0</em>). At the same time, weak noise on the InceptionV3 network gives an average score gain of about 1%. This is very strange, but interesting. Perhaps this is a sampling error.</p><p><strong>Experiment 2.</strong> By how much the picture quality needs to be degraded for the network to make a mistake? The experiment was carried out on 10,000 random pictures with different classes from the <a href="https://cocodataset.org/">COCO dataset</a>. A picture is selected and noise is superimposed on it with varying degrees. The resulting noisy images are sent to the network and the minimum noise level is selected at which the network makes a mistake according to the top-1 metric, i.e. the other class gets the maximum score. This experiment is performed on each of 10,000 randomly selected images. The results are averaged and presented in the following table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/979/1*8N-zoyDjxxruxUV20THVAw.png" /><figcaption>Mean minimal noise level when network mistakes</figcaption></figure><p><strong>Conclusion 2.</strong> Here the InceptionV3 network is selected. On average, for its error, noise with a minimum level of 0.26 is enough. At the same time, MobileNet and ResNet50 networks, on average, make mistakes with less noisy pictures with a noise figure of 0.19.</p><p><strong>Conclusion</strong></p><p>In real life, images that are submitted to standard pre-trained CNN networks differ in quality from those on which the model has been trained. Consequently, the results will be much lower than expected. For example, for the original picture (Fig. 9(1)) the ResNet50 network predicts an object of class “steam locomotive” (with score=0.999) and for the picture with a noise figure of 0.2 (Fig. 9 (2)), the ResNet50 network is mistaken and responds with “chainlink fence” (with score=0.3) and the score for the “steam locomotive” class is 0.000213.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*z41w0XrF-BNZT2JWn-_j9g.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*2yBoPFuzwfEP4yYrpJXWIw.png" /><figcaption>Figure: 9 Original image and noisy image with level = 0.2</figcaption></figure><p>Therefore, be careful when working with pre-trained models.</p><p>We conduct various studies in order to understand how well the models are trained and incorporate the best results into our product <a href="https://deelvin.com/ml-visualizer">ML Visualizer</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f29c5ddf3eb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/deelvin-machine-learning/the-impact-of-artifacts-on-the-accuracy-of-network-prediction-f29c5ddf3eb">The Impact of artifacts on the accuracy of network prediction.</a> was originally published in <a href="https://medium.com/deelvin-machine-learning">Deelvin Machine Learning</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[VQ Analyzer — Guided Tour. Part Two. “Frame View” Functionality.]]></title>
            <link>https://medium.com/vicuesoft-techblog/vq-analyzer-and-frame-size-view-functionality-c677693145e?source=rss-880cec06509a------2</link>
            <guid isPermaLink="false">https://medium.com/p/c677693145e</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[medium]]></category>
            <category><![CDATA[video-encoding]]></category>
            <category><![CDATA[streaming]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[Maiya Rozhnova]]></dc:creator>
            <pubDate>Thu, 05 Dec 2019 14:33:34 GMT</pubDate>
            <atom:updated>2020-03-30T15:37:01.797Z</atom:updated>
            <content:encoded><![CDATA[<h3>VQ Analyzer — Guided Tour. Part Two. “Frame View” Functionality.</h3><figure><img alt="VQ Analyzer — Guided Tour. Series Two. “Frame View”" src="https://cdn-images-1.medium.com/max/1024/1*SOHwh7YNTg2JxFNZ6fU4RA.jpeg" /><figcaption>VQ Analyzer — Guided Tour. Series Two. “Frame View”</figcaption></figure><p>Welcome to the second part of our VQ Analyzer (Video Codec Analyzer) — Guided Tour!</p><p>Still not familiar with VQ Analyzer?</p><p>Then I recommend you give the <a href="https://medium.com/vicuesoft-techblog/vq-analyzer-guided-tour-yuv-viewer-functionality-c3f6f6968b4e">first part of our Guided Tour</a> a read. Briefly, VQ Analyzer is a tool that supports many video codec formats such as HEVC/H.265, VP9, AVC/H.264, MPEG2, AV1, and VVC/H.266.</p><p>So, if you want to know more information about the frame, this is easy to do. All supported codecs have a Frame-size view. Just open the “Buffer” menu. When you choose the “Buffer” menu from the popup toolbar, the frame size view will appear by default. This is a bar chart plotted with frame sizes. Each bar is colored according to the frame type (for example, <a href="https://en.wikipedia.org/wiki/Video_compression_picture_types">red — intra picture I-frame, blue — P-picture, green — B-picture</a>). When you move the mouse along the bar, the current frame is highlighted and the tooltip shows information about the current frame. By clicking on the selected frame, you can decode it.</p><figure><img alt="pic 1. VQ Analyzer (VVC, AV1, VP9, HEVC &amp; AVC codecs) ver.4.2. Overview Buffer menu." src="https://cdn-images-1.medium.com/max/906/1*nLyXK50nRjUtPkWip2ythg.png" /><figcaption>pic 1. VQ Analyzer ver.4.2. Overview Buffer menu.</figcaption></figure><p>When you hold down the left mouse button and move it, all plots move along both axes. Double clicking on the canvas area resets plot into the default state. You can zoom in and zoom out with a mouse wheel on both axes when the cursor is inside the canvas. If the mouse is on an axis (below the canvas, for example, x-axis) you can zoom, pan or double click on only on that axis. In that case, all actions are applied to that axis only.</p><p>The movement of the plots is restricted to the positive values only; you can’t move or zoom in a negative direction. The currently decoded frame is shown with a vertical line and frame number on it.</p><p>Now let’s move on to some useful details. On the right axis, the average slice QP values are shown. When full stream analysis is complete, the VQ Analyzer adds an average block QP plot that is also attached to the right axis. By double-clicking on ‘Moving average’ label item, sliding window size can be adjusted in the separate dialog box.</p><figure><img alt="pic 2. VQ Analyzer (VVC, AV1, VP9, HEVC &amp; AVC codecs) ver.4.2. Overview Buffer menu." src="https://cdn-images-1.medium.com/max/1024/1*banwU36KoxcAYDHHKJ3kuw.png" /><figcaption>pic 2. VQ Analyzer ver.4.2. Overview Buffer menu.</figcaption></figure><p>By double-clicking on ‘[30fps]’ label item, the fps value can be adjusted in the separate dialog box. By clicking on legend item one can switch it on or off. The legend panel can be moved by dragging the mouse.</p><figure><img alt="pic 3. VQ Analyzer (VVC, AV1, VP9, HEVC &amp; AVC codecs) ver.4.2. FPS value" src="https://cdn-images-1.medium.com/max/1024/1*ttoG37W4xpxFK_lhhD8r6A.png" /><figcaption>pic 3. VQ Analyzer ver.4.2. FPS value</figcaption></figure><p>Let me tell you about the “HRD” sub-mode. It is enabled if a stream has HRD buffer fullness plot and works in the same way as for frame size plot. It is possible to get buffer state and picture parameters in each point of the plot where the monotonic behavior changes. With a right-click on the central area of the plot, VQ Analyzer shows additional options for plot adjustment. In the same popup menu, you can export HRD timings into .csv file.</p><figure><img alt="pic 4. VQ Analyzer (VVC, AV1, VP9, HEVC &amp; AVC codecs) ver.4.2. Export to file" src="https://cdn-images-1.medium.com/max/1024/1*XGVvmEe9jvnxa7-NK-pyMw.png" /><figcaption>pic 4. VQ Analyzer ver.4.2. Export to file</figcaption></figure><p>Keep it up! Awesome!</p><p>Now you know a bit more about our tool. We will keep you posted and see you soon…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c677693145e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/vicuesoft-techblog/vq-analyzer-and-frame-size-view-functionality-c677693145e">VQ Analyzer — Guided Tour. Part Two. “Frame View” Functionality.</a> was originally published in <a href="https://medium.com/vicuesoft-techblog">vicuesoft-techblog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>