Akila

akila

Enhancing Data Quality: Conclusion and Future Work, and References

Startups Of The Year 2023: Asia Winners

have been the talk of the town in the cryptocurrency world for the past couple of weeks. In early October, Tesla and SpaceX CEO Elon Musk tweeted a picture of his new pet dog, a Shiba Inu breed. Since then, there has been a constant buzz around meme tokens. Meme-based coins is the most well-known meme cryptocurrency, but other cryptos have recently emerged as well. Two of such currencies are Shiba Inu and Akita Inu. Dogecoin Both tokens are named after Japanese dog breeds, but the similarities don’t end there. In this article, we’ll discuss both these coins, their similarities and differences, and which one is the better option in the current climate. But first, let’s discuss these two separately. What is Shiba Inu? Shiba Inu (SHIB) is an Ethereum-based coin that has witnessed a this year. This rise can be attributed to rampant speculation on its price by investors and strong community engagement. The token was created on 1st August 2020 by an anonymous founder known as “Ryoshi”. surge in popularity During the token’s launch, one quadrillion SHIB tokens were minted. Half of its supply was locked in Uniswap SHIB/ETH liquidity pool. This pool is basically a decentralized exchange where investors trade pairs of assets from liquidity pools. The remaining 50% of the tokens were donated to Vitalik Buterin, the founder of Ethereum. Buterin ended up by sending them to a dead crypto wallet address. The rest were donated to an Indian Covid-19 relief fund and other charities. burning the majority of them The Shiba Inu universe consists of a decentralized exchange called Shibaswap and two other tokens called ‘LEASH’ and ‘BONE’. The community is also ever-present in a rescue campaign for Shiba Inu dogs. The of SHIB is $0.00005643, with a 24-hour trading volume of $19.0B. Its market capitalization stands at $22.5B. current price What is Akita Inu? Inspired heavily by Dogecoin, Akita Inu (AKITA) was launched on 1st February this year. It is a decentralized meme currency built on the Ethereum network using the ERC-20 protocol. It has recently set the crypto world abuzz with its lightning-fast development in association with the . Polarfox community A couple of months into its launch, Akita Inu was added on numerous exchanges, from MXC and HotBot to Poloniex. The token is part of the AKITA community, which is backed by the . The network and its various affiliations, such as social media platforms and webspace, are being fully funded by the AKITA. AKITA network AKITA prides itself on being a decentralized, community-driven experiment with no founders or team tokens. The community aims to move forward through collective agreement over decisions regarding its future. Within three months of the token’s launch, over 15,000 new investors held it, and another 20,000 joined the AKITA project’s Telegram channel. Akita Inu’s is $0.00000498 with a 24-hour trading volume of $19.5B. current price What Are the Differences and Similarities Between Shiba Inu and Akita Inu? Shiba Inu was launched in August 2020 while Akita Inu came into being six months later in February 2021. Shiba Inu was launched by an anonymous founder, whereas Akita Inu was established through the AKITA network, a community with no formal founder. Other than these, there is not much difference between the two. Some of the similarities between the two coins are: Both are dog-based meme coins. Both of them have witnessed tremendously volatile spikes over the past couple of months. Dogecoin has inspired both. Both have strong community links. Both are based on the Ethereum blockchain. Which is the Better Option? To be perfectly honest, both options are speculative investments at this point. The primary reason that people are buying them is that they expect their prices to explode sooner rather than later. That is an understandable sentiment, but you should always be mindful when making such investments. If you want to invest in a coin based on momentum, Akita Inu is the better option. Because it’s relatively newer, it has built up greater momentum and shows a good enough growth potential. If you want a safer option, go with Shiba Inu. Given that it has greater market experience than its counterpart, SHIB could possibly offer you a bigger safety net. Both Shiba Inu and Akita Inu are undoubtedly making waves in the cryptocurrency world right now. Having taken inspiration from the original meme currency, Dogecoin, both of these tokens have been steadily growing in popularity. Where Can You Buy Shiba Inu and Akita Inu? You’re probably not going to find these meme coins on any centralized exchange. Currently, they are too obscure to be listed even on , one of the top altcoin exchanges on the globe. Binance You should go for decentralized exchanges, like UniSwap, as they are the best place for investors seeking to buy with Shiba or Akita Inu at this point. Keep in mind that since both are Ethereum-based altcoins, you’ll need an ERC-20 compatible digital wallet to store them. As mentioned earlier, investing in either of these currencies is a risky move due to their young lifespan and highly volatile nature. Most people who are investing in them right now are doing so due to a fear of missing out. Having said that, both coins have pretty strong communities linked to them. If you really want to invest in these meme-based coins, make sure you conduct your proper research beforehand! Let us know on what you like or don't like about Shiba Inu and Akita Inu! Hackernoon Community The opinions in this article belong to the author alone, and nothing here constitutes professional investment advice. Please do your own thorough research before making any investment decisions. Disclaimer: References: https://apnews.com/article/business-technology-81b7d718e7f495aed57937ca87aa34ea https://hackernoon.com/the-pros-and-cons-of-staking-with-cardano-o13m33dg

Shiba Inu vs. Akita Inu: The Great Memecoin War 

pictured: research 😋 What is Akita? Akita is a state management pattern, built on top of RxJS, which takes the idea of multiple data stores from Flux and the immutable updates from Redux, along with the concept of streaming data, to create the Observable Data Stores model. Akita encourages simplicity. It saves you the hassle of creating boilerplate code and offers powerful tools with a moderate learning curve, suitable for both experienced and inexperienced developers alike. Among its many capabilities, Akita lets you manage multiple entities while maintaining a single entity with an active state, as an indication of the entity we’re currently dealing with. In this article, we’ll learn how to use this functionality, and what better way to do that than to create a page that deals with the best of all dishes, beloved by the world*, pizza. The Pizza Store We start by creating our model and entity store. It will hold entities which in this case represent pizzas — each with an id and a list of toppings (in this ideal world all the pizzas are family-sized). Here is the representation of the pizza: Next, we’ll create an Akita entity store to manage the pizzas. Note that almost all of the methods required to manage the store are already built-in. To create it you can use the accompanying : CLI In addition to the basic entity store, it contains the method. It creates a new pizza, adds it, and sets it as active. Since this requires more than one store action, we optimize the method by adding Akita’s transaction decorator — it ensures that anybody subscribed to the store’s value will only be triggered once. addNewPizza() Another added method in the store is a topic toggling function, which allows us to add or remove a selected topping. We also add an interface that extends Akita’s EntityState interface. This will denote which pizza entity we’re currently “editing” (i.e., adding or removing toppings from). We also add the interface that extends Akita’s interface and the . This is the state which will denote which pizza is currently active. PizzasState EntityState getInitialActiveState() To communicate with the store, we use a service and a query: The Pizza Query The query extends Akita’s built-in query, which is used to get entities from the store (as noted Akita’s , the entity comes with a variety of selection functions, some returning entities, and some observables). The only method we need to add is , which will allow us to get an observable containing the toppings of the pizza that’s currently active. documentation selectPizzaToppings() The Pizza Service The service allows us to modify the store’s contents as well as access it’s topping function. In applications where data arrives from an external source, the service would also be in charge of calling a data service and passing on its response to the store. The Pizza Component Finally, we use the query and the service in a component which displays the store content on the page, as well as controls to add pizzas and edit the toppings for the active pizza: In summary: 🍕 Through Akita we can not only store entities, but also manage them more efficiently, since it also comes with built-in support for managing an active state. No more adding toppings to the wrong pizza Here are some more articles about Akita: _It’s only been three weeks since Akita’s latest release and we’ve already come up with hot new features ! (v1.2.0)_engineering.datorama.com 💣 What’s New in Akita for Angular: We’ve Added Your Top Requested Features 🔥 _Every developer knows state management is difficult. Continuously keeping track of what has been updated, why, and…_netbasal.com 🚀 Introducing Akita: A New State Management Pattern for Angular Applications _This is the second part of the introduction to Akita (the first part can be found here). In this part, we’ll create…_engineering.datorama.com 👷 Building a Shopping Cart in Angular Using Akita _In this article, we’ll build an Angular application which lists movies which arrive from a nested API response. We’ll…_netbasal.com Working with Normalized Data in Akita and Angular _It’s only been two weeks since Akita’s initial announcement, and the response has been tremendous. We want to thank…_engineering.datorama.com 🚀 What’s New in Akita v1.1.0 🔥 _akita - 🚀 Simple and Effective State Management for Angular Applications_github.com datorama/akita * ok, at least by me and the Teenage Mutant Ninja Turtles. Follow me on Medium to read more about Angular, Akita, JS!

Let’s Build a Pizza Store with Akita — State Management for Angular Applications

Ensuring Reproducibility in AI Research: Code and Pre-trained Weights Open-Sourced

This started on a Saturday night. If you are very social like me, you would know that there is no better time to do some coding than a peaceful Saturday night. So I opened up a pet project I've been working on and realized that it wasn't pushed to Github yet. I didn't remember the commands to set a remote repo and could have easily Googled or "ChatGPTed" it. But, wouldn't it be cooler to add another layer of abstraction and just tell the computer to "set this projects remote as such and such", specially in this era of intelligent agents? And wouldn't it be even cooler to build that agent?. And that's exactly what I did, instead of spending a few seconds on finding the commands to set the remote repo. I started solving the problem backwards. I would need a way to run shell commands from a program. That's easy, the subprocess module in Python. import subprocess

def run_shell_command(command):
    try:
        # Run the shell command
        result = subprocess.run(command, shell=True, check=True, text=True, capture_output=True)
        # Return the command output
        return result.stdout
    except subprocess.CalledProcessError as e:
        # Return the error output if the command fails
        return e.stderr

print(run_shell_command('pwd')) Now I need a way to decide what commands to run. That's where the intelligence comes in. It needs to take the natural language input and convert them to shell commands. Large Language Models (LLMs) are good at this sort of things. So I tried the following prompt on ChatGPT. I'm computer program created to assist a human. Currently the human is working on a DevOps task. He asked me to "ssh to the development server and install python". Please tell me what shell commands to run to do the activity. If you need more information please let me know what information you need. Please respond in the following manner and don't include anything else in the response.
Type: [Can be either "Commands" or "More information"]
Response: [List of shell commands or list of more information needed, separated by commas]

Example response 1:
Type: More information
Response: user id, key path

Example response 2:
Type: Commands
Response: ssh -i 'keyfile.pem' user1@server
It worked surprisingly well most of the time.

This was the response.

Type: More information
Response: user id, server IP or hostname, key path or password, operating system type (e.g., Ubuntu, CentOS) And after passing the inputs, it returned the list of commands as, Type: Commands
Response: ssh -i 'key.pem' user1@192.168.1.8, sudo yum install python3 -y Not exactly production ready, but this is a promising start. On this high note I had to stop for the day one, or rather hour one since I'm no longer the young man I once was and it was already 10 PM. A week later... Zooming out a little bit, "how would I use this?". I would open up a project on the terminal, and type " set the remote repo for this project as " . Then the agent will ask the LLM for the commands to run. If it needs more information, it will prompt me. After getting the information, it will send them to the LLM, for which the LLM will give the commands or ask for more information. This will repeat until a command runs. If the command is successful, it will stop. But if it returns errors the agent will prompt the LLM for commands to resolve the issue. Also, with each request to the LLM , the agent will send the conversation history in window with a suitable size. This will provide the context to the LLM. We would need to make the queries to LLM a little abstract to make the agent handle a wider range of tasks. After all, it wouldn't be very useful if its only capable of setting remote repo URLs. At the same time, we need to clearly defile its scope. In this case it would be an agent for running shell commands. To help handling a range of commands, we can parameterize the prompt. Those parameters would be, The natural language input from the human.
Context: This is little tricky, I will use the conversation history for now.
Any errors returned by running a command. In addition to that we will have to maintain the state such as executing a command or getting more info. Let's code it. I've changed the LLMs output to a JSON format string since it's easier to write the processing part that way. I tested it with a few simple commands and they worked as expected. Seems alright. Let's try another one. That's not what I asked for. May be we need to be more specific. That's more like it. Although I should definitely add a mechanism to verify the commands before running them. That should prevent the agent from doing something crazy. Also, explaining a command before it runs would be a good feature - but not for now. answer = input(f" Shall I run '{command}'? (Yes/ No) ")
                if answer.lower()=='yes': # Execute the command So, it kind of works, but we need to make it easily accessible. Creating an alias did the trick. I added the following to ~/.bashrc. alias shelly='/home/akalanka/projects/shelly/venv/bin/python3 /home/akalanka/projects/shelly/main.py' Let's see how well "Shelly" fulfills her purpose. First I told Shelly to create the remote repo, but it did't work because it was trying to setup gh CLI tools authentication, which was too complex for a simple tool like this. So I created the remote repo and then asked to set it as the origin of the local repo, which also failed the first time. But after improving the prompt template, I asked her to correct the mistake, which actually worked. Then I went ahead and asked her to commit and push her own code, which also was done nicely enough (ignoring the fact that she ignored the instruction about the commit message). It's not much useful for commands I use frequently, which I remember, because it's quicker and more reliable to run the shell command directly. But for other cases this actually seem to help. So about a week later, I was finally able to set the remote repo for the project. Great success!. What a way to spend weekend evenings!. Obviously, a lot can be done to improve this. To start, some way of persisting the user inputs between the invocations could smooth things up. Using LangChain could be a good idea. Let me know what you think. Also feel free to check out the source code and open a PR to make it more intelligent. It could use some help. Hey, you can use the Shelly to push your feature, hopefully. P.S. This was entirely written by a human. Absolutely no intelligence - artificial or otherwise was involved in the writing. This started on a Saturday night. If you are very social like me, you would know that there is no better time to do some coding than a peaceful Saturday night. So I opened up a pet project I've been working on and realized that it wasn't pushed to Github yet. I didn't remember the commands to set a remote repo and could have easily Googled or "ChatGPTed" it. But, wouldn't it be cooler to add another layer of abstraction and just tell the computer to "set this projects remote as such and such", specially in this era of intelligent agents? And wouldn't it be even cooler to build that agent?. And that's exactly what I did, instead of spending a few seconds on finding the commands to set the remote repo. I started solving the problem backwards. I would need a way to run shell commands from a program. That's easy, the subprocess module in Python. import subprocess

def run_shell_command(command):
    try:
        # Run the shell command
        result = subprocess.run(command, shell=True, check=True, text=True, capture_output=True)
        # Return the command output
        return result.stdout
    except subprocess.CalledProcessError as e:
        # Return the error output if the command fails
        return e.stderr

print(run_shell_command('pwd')) import subprocess

def run_shell_command(command):
    try:
        # Run the shell command
        result = subprocess.run(command, shell=True, check=True, text=True, capture_output=True)
        # Return the command output
        return result.stdout
    except subprocess.CalledProcessError as e:
        # Return the error output if the command fails
        return e.stderr

print(run_shell_command('pwd')) Now I need a way to decide what commands to run. That's where the intelligence comes in. It needs to take the natural language input and convert them to shell commands. Large Language Models (LLMs) are good at this sort of things. So I tried the following prompt on ChatGPT. I'm computer program created to assist a human. Currently the human is working on a DevOps task. He asked me to "ssh to the development server and install python". Please tell me what shell commands to run to do the activity. If you need more information please let me know what information you need. Please respond in the following manner and don't include anything else in the response.
Type: [Can be either "Commands" or "More information"]
Response: [List of shell commands or list of more information needed, separated by commas]

Example response 1:
Type: More information
Response: user id, key path

Example response 2:
Type: Commands
Response: ssh -i 'keyfile.pem' user1@server
It worked surprisingly well most of the time.

This was the response.

Type: More information
Response: user id, server IP or hostname, key path or password, operating system type (e.g., Ubuntu, CentOS) I'm computer program created to assist a human. Currently the human is working on a DevOps task. He asked me to "ssh to the development server and install python". Please tell me what shell commands to run to do the activity. If you need more information please let me know what information you need. Please respond in the following manner and don't include anything else in the response.
Type: [Can be either "Commands" or "More information"]
Response: [List of shell commands or list of more information needed, separated by commas]

Example response 1:
Type: More information
Response: user id, key path

Example response 2:
Type: Commands
Response: ssh -i 'keyfile.pem' user1@server
It worked surprisingly well most of the time.

This was the response.

Type: More information
Response: user id, server IP or hostname, key path or password, operating system type (e.g., Ubuntu, CentOS) And after passing the inputs, it returned the list of commands as, Type: Commands
Response: ssh -i 'key.pem' user1@192.168.1.8, sudo yum install python3 -y Type: Commands
Response: ssh -i 'key.pem' user1@192.168.1.8, sudo yum install python3 -y Not exactly production ready, but this is a promising start. On this high note I had to stop for the day one, or rather hour one since I'm no longer the young man I once was and it was already 10 PM. A week later... Zooming out a little bit, "how would I use this?". I would open up a project on the terminal, and type " set the remote repo for this project as " . Then the agent will ask the LLM for the commands to run. If it needs more information, it will prompt me. After getting the information, it will send them to the LLM, for which the LLM will give the commands or ask for more information. This will repeat until a command runs. If the command is successful, it will stop. But if it returns errors the agent will prompt the LLM for commands to resolve the issue. Also, with each request to the LLM , the agent will send the conversation history in window with a suitable size. This will provide the context to the LLM. We would need to make the queries to LLM a little abstract to make the agent handle a wider range of tasks. After all, it wouldn't be very useful if its only capable of setting remote repo URLs. At the same time, we need to clearly defile its scope. In this case it would be an agent for running shell commands. To help handling a range of commands, we can parameterize the prompt. Those parameters would be, The natural language input from the human. Context: This is little tricky, I will use the conversation history for now. Any errors returned by running a command. The natural language input from the human. Context: This is little tricky, I will use the conversation history for now. Any errors returned by running a command. In addition to that we will have to maintain the state such as executing a command or getting more info. Let's code it. I've changed the LLMs output to a JSON format string since it's easier to write the processing part that way. I tested it with a few simple commands and they worked as expected. Seems alright. Let's try another one. That's not what I asked for. May be we need to be more specific. That's more like it. Although I should definitely add a mechanism to verify the commands before running them. That should prevent the agent from doing something crazy. Also, explaining a command before it runs would be a good feature - but not for now. answer = input(f" Shall I run '{command}'? (Yes/ No) ")
                if answer.lower()=='yes': # Execute the command answer = input(f" Shall I run '{command}'? (Yes/ No) ")
                if answer.lower()=='yes': # Execute the command So, it kind of works, but we need to make it easily accessible. Creating an alias did the trick. I added the following to ~/.bashrc. alias shelly='/home/akalanka/projects/shelly/venv/bin/python3 /home/akalanka/projects/shelly/main.py' alias shelly='/home/akalanka/projects/shelly/venv/bin/python3 /home/akalanka/projects/shelly/main.py' Let's see how well "Shelly" fulfills her purpose. First I told Shelly to create the remote repo, but it did't work because it was trying to setup gh CLI tools authentication, which was too complex for a simple tool like this. So I created the remote repo and then asked to set it as the origin of the local repo, which also failed the first time. But after improving the prompt template, I asked her to correct the mistake, which actually worked. Then I went ahead and asked her to commit and push her own code, which also was done nicely enough (ignoring the fact that she ignored the instruction about the commit message). It's not much useful for commands I use frequently, which I remember, because it's quicker and more reliable to run the shell command directly. But for other cases this actually seem to help. So about a week later, I was finally able to set the remote repo for the project. Great success!. What a way to spend weekend evenings!. Obviously, a lot can be done to improve this. To start, some way of persisting the user inputs between the invocations could smooth things up. Using LangChain could be a good idea. Let me know what you think. Also feel free to check out the source code and open a PR to make it more intelligent. It could use some help. Hey, you can use the Shelly to push your feature, hopefully. source code P.S. This was entirely written by a human. Absolutely no intelligence - artificial or otherwise was involved in the writing.

Building a (somewhat) Intelligent Agent

Stream Processing - Windows

Event Time Processing with Flink and Beam - Power of Real time Analytics

An essential bottleneck in deep learning is data availability. Effective training of models requires a lot of data. Plenty of techniques are used for dataset augmentation to increase the number of training examples. Typical data augmentations include a very limited set of transformations like rotation, reflection, cropping, translation, and scaling of existing images. A little additional information can be achieved from small changes to the images. Synthetic data augmentation is a new, advanced type of data augmentation. High-quality synthetic data produced by a generative model facilitates more variability and enriches the dataset to further improve the model. The huge progress of generative models provides powerful tools for the creation of new data from a trained distribution. Mathematically, generative models work as follows. Black dots on the right side of Figure 1 represent images from the true data distribution. The generative model, the yellow one, maps unit Gaussian distribution into generated distribution, the green one. The shape of the generated distributionа depends on model parameters θ. The goal of training is finding the parameters θ, which minimize the difference between generated and true data distributions. Among the most popular generative models are Generative Adversarial Networks (GAN), Variational Autoencoders (VAE), and diffusion models. GAN consists of two models, a generator and a discriminator, which compete with each other while making each other stronger at the same time. The discriminator learns to distinguish between real or fake input images, while the generator learns to generate fake samples that are indistinguishable from the discriminator. VAE consists of two components: an encoder and a decoder. The encoder encodes input data to a latent representation, specifically into Gaussian distribution. The decoder decodes latent points from Gaussian distribution back into data space. Diffusion models progressively add Gaussian noise to data, then learn to reverse this process for sample generation. Let’s see how we can use GANs for image augmentation. Sometimes, it is impossible or laborious to get a big, diverse, quality dataset. It’s beneficial to train GAN on that limited data before training a model for tasks like classification, object detection, segmentation, etc. Once we train a model, we can generate as much data as we want. Of course, the diversity of such a synthesis is limited as our trained GAN just replicates training data. Quite a different matter if we fine-tune GAN pre-trained on a bigger dataset. In this case, pre-trained GAN can generate rich, diverse data in advance. The fine-tuning step learns training data distribution while it retains properties of the pre-trained model if distributions of pre-train and train data are close enough. This allows you to qualitatively increase the size of the dataset by several orders of magnitude. A useful property of GANs is the ability to manipulate a process of image generation. Let’s take a look at the most popular GAN in the field of human face generation — StyleGan[1]. Instead of directly mapping input 512-dimensional Gaussian noise to the image, it maps it to an intermediate latent code of the same dimension. Neural net learns to disentangle face representation and creates meaningful latent space. It allows the manipulation of human faces. There are directions in this latent space that correspond to face modifications like gender, haircut, emotions, shape, etc. Varying latent code toward some direction, we alter the generated image respectively. Another generative model SemanticStyleGAN[2] gives control of the generation of each facial semantic part like shape, color, eye, eyebrow, mouth, nose, hair, background, etc. The authors suggest using different latent codes for each facial part with a corresponding local generator for each latent code. Local generators map the latent codes into facial parts with depth masks, and then they are combined into a single image. This provides more precise local controls over the face image shown in Figure 2. The Augmentation process looks as follows. We take a generated image from unit gaussian distribution or invert any face photo to latent space. Inversion can be made by an optimization algorithm. For complete similarity between our and inverted image, we can fine-tune GAN on calculated latent code for approximately 300 iterations. Now, we can alter face semantics by mixing our latent codes with latent codes of other faces. For example, if we solve the problem of face recognition, we would be interested in retaining the identity and adding modifications to lighting conditions and haircuts. For this purpose, we freeze all latent codes except ones responsible for lightning and haircuts and vary them as demonstrated in figures 3, and 4. The ability of generative models to synthesize plausible, diverse images opens new opportunities to boost the performance of deep learning models. In this article, we talked about several methods of how we can use GANs for face data augmentation. Thank you for reading. I hope this helps you to improve your models. References: A Style-Based Generator Architecture for Generative Adversarial Networks. Tero Karras, Samuli Laine, Timo Aila.
SemanticStyleGAN: Learning Compositional Generative Priors for Controllable Image Synthesis and Editing. Yichun Shi, Xiao Yang, Yangyue Wan, Xiaohui Shen.
Project site of SemanticStyleGAN: https://semanticstylegan.github.io An essential bottleneck in deep learning is data availability. Effective training of models requires a lot of data. Plenty of techniques are used for dataset augmentation to increase the number of training examples. Typical data augmentations include a very limited set of transformations like rotation, reflection, cropping, translation, and scaling of existing images. A little additional information can be achieved from small changes to the images. Synthetic data augmentation is a new, advanced type of data augmentation. High-quality synthetic data produced by a generative model facilitates more variability and enriches the dataset to further improve the model. The huge progress of generative models provides powerful tools for the creation of new data from a trained distribution. Mathematically, generative models work as follows. Black dots on the right side of Figure 1 represent images from the true data distribution. The generative model, the yellow one, maps unit Gaussian distribution into generated distribution, the green one. The shape of the generated distributionа depends on model parameters θ. The goal of training is finding the parameters θ, which minimize the difference between generated and true data distributions. Among the most popular generative models are Generative Adversarial Networks (GAN), Variational Autoencoders (VAE), and diffusion models. GAN consists of two models, a generator and a discriminator, which compete with each other while making each other stronger at the same time. The discriminator learns to distinguish between real or fake input images, while the generator learns to generate fake samples that are indistinguishable from the discriminator. VAE consists of two components: an encoder and a decoder. The encoder encodes input data to a latent representation, specifically into Gaussian distribution. The decoder decodes latent points from Gaussian distribution back into data space. Diffusion models progressively add Gaussian noise to data, then learn to reverse this process for sample generation. Let’s see how we can use GANs for image augmentation. Sometimes, it is impossible or laborious to get a big, diverse, quality dataset. It’s beneficial to train GAN on that limited data before training a model for tasks like classification, object detection, segmentation, etc. Once we train a model, we can generate as much data as we want. Of course, the diversity of such a synthesis is limited as our trained GAN just replicates training data. Quite a different matter if we fine-tune GAN pre-trained on a bigger dataset. In this case, pre-trained GAN can generate rich, diverse data in advance. The fine-tuning step learns training data distribution while it retains properties of the pre-trained model if distributions of pre-train and train data are close enough. This allows you to qualitatively increase the size of the dataset by several orders of magnitude. A useful property of GANs is the ability to manipulate a process of image generation. Let’s take a look at the most popular GAN in the field of human face generation — StyleGan[1]. Instead of directly mapping input 512-dimensional Gaussian noise to the image, it maps it to an intermediate latent code of the same dimension. Neural net learns to disentangle face representation and creates meaningful latent space. It allows the manipulation of human faces. There are directions in this latent space that correspond to face modifications like gender, haircut, emotions, shape, etc. Varying latent code toward some direction, we alter the generated image respectively. Another generative model SemanticStyleGAN[2] gives control of the generation of each facial semantic part like shape, color, eye, eyebrow, mouth, nose, hair, background, etc. The authors suggest using different latent codes for each facial part with a corresponding local generator for each latent code. Local generators map the latent codes into facial parts with depth masks, and then they are combined into a single image. This provides more precise local controls over the face image shown in Figure 2. The Augmentation process looks as follows. We take a generated image from unit gaussian distribution or invert any face photo to latent space. Inversion can be made by an optimization algorithm. For complete similarity between our and inverted image, we can fine-tune GAN on calculated latent code for approximately 300 iterations. Now, we can alter face semantics by mixing our latent codes with latent codes of other faces. For example, if we solve the problem of face recognition, we would be interested in retaining the identity and adding modifications to lighting conditions and haircuts. For this purpose, we freeze all latent codes except ones responsible for lightning and haircuts and vary them as demonstrated in figures 3, and 4. The ability of generative models to synthesize plausible, diverse images opens new opportunities to boost the performance of deep learning models. In this article, we talked about several methods of how we can use GANs for face data augmentation. Thank you for reading. I hope this helps you to improve your models. References: References: A Style-Based Generator Architecture for Generative Adversarial Networks. Tero Karras, Samuli Laine, Timo Aila. SemanticStyleGAN: Learning Compositional Generative Priors for Controllable Image Synthesis and Editing. Yichun Shi, Xiao Yang, Yangyue Wan, Xiaohui Shen. Project site of SemanticStyleGAN: https://semanticstylegan.github.io A Style-Based Generator Architecture for Generative Adversarial Networks. Tero Karras, Samuli Laine, Timo Aila. SemanticStyleGAN: Learning Compositional Generative Priors for Controllable Image Synthesis and Editing. Yichun Shi, Xiao Yang, Yangyue Wan, Xiaohui Shen. Project site of SemanticStyleGAN: https://semanticstylegan.github.io https://semanticstylegan.github.io https://semanticstylegan.github.io

Stories, News & Mentions about AKILA

Akila’s Stories on HackerNoon