The Power of Advanced Encoders and Decoders in Generative AI

Introduction

In the dynamic realm of Artificial Intelligence, the fusion of technology and creativity has birthed innovative tools that push the boundaries of human imagination. Among these pioneering advancements lies the sophisticated world of Encoders and Decoders in Generative AI. This evolution revolutionises how we create, interpret, and interact with art, language, and even reality.

Learning Objectives

• Understand the role of Encoders and Decoders in Generative AI and their significance in creative applications.
• Learn about advanced AI models like BERT, GPT, VAE, LSTM, and CNN and their practical use in encoding and decoding data.
• Explore real-time applications of Encoders and Decoders across diverse domains.
• Gain insights into the ethical considerations and responsible use of AI-generated content.
• Recognize creative collaboration and innovation potential by applying advanced Encoders and Decoders.

This article was published as a part of the Data Science Blogathon.

The Rise of Encoders and Decoders

In the ever-evolving world of technology, Encoders and Decoders have become the unsung heroes, bringing a creative twist to Artificial Intelligence (AI) and Generative AI. They are like the magic wands AI uses to understand, interpret, and create things like art, text, sounds, and many more in ways that dazzle us all.

Here’s the deal: Encoders are like the super-observant detectives. They closely examine things, whether pictures, sentences, or sounds. They catch all the tiny details and patterns like a detective piecing together clues.

Now, Decoders are the creative wizards. They take what Encoders found and transform it into something new and exciting. It’s like a wizard turning clues into magic spells that create art, poems, or even languages. This combination of Encoders and Decoders opens the door to a world of creative possibilities.

In simpler terms, Encoders and Decoders in AI are like detectives and wizards working together. The detectives understand the world, and the wizards turn that understanding into amazing creations. This is how they’re changing the game in art, language, and so much more, making technology not just innovative but brilliantly creative.

The Building Blocks: Encoders and Decoders

At the heart of generative AI are Encoders and Decoders, fundamental components that transform data from one form to another, making it a core pillar of creative AI. Understanding their roles helps in grasping the immense creative potential they unlock.

• The Encoder: This component is all about understanding. It breaks down input data – an image, text, or sound – into its core components, capturing its essence and extracting intricate patterns. Imagine it as an attentive artist who keenly observes a scene’s details, colors, and shapes.
• The Decoder: Here’s where the magic happens. The Decoder translates the extracted information into something new – a piece of art, a poetic verse, or even an entirely different language. The creative genius transforms the essence of the Encoder into a masterpiece.

Real-time Code Example

To understand the concepts of Encoders and Decoders in Generative AI better, let’s consider a real-time code example for text-to-image generation. We’ll use the Hugging Face Transformers library, which offers pre-trained models for various generative tasks. In this example, we’ll use an Encoder to interpret a text description and a Decoder to create an image based on that description.

from transformers import pipeline

# Initialize a text-to-image generation pipeline
text_to_image_generator = pipeline("text2image-generation", model="EleutherAI/gpt-neo-2.7B")

# Define a text description
text_description = "A serene lake at dusk"

# Generate an image based on the text description
generated_image = text_to_image_generator(text_description, max_length=30, do_sample=True)

# Display or save the generated image
generated_image[0].show()

Explanation

• We start by importing the pipeline class from the Hugging Face Transformers library. The pipeline class simplifies using pre-trained models for various NLP and generative tasks.
• We initialize a text_to_image_generator pipeline, specifying that we want to perform text-to-image generation. We also specify the pre-trained model to use, in this case, “EleutherAI/gpt-neo-2.7B.”
• Next, we define a text_description. This text description will be the input for our Encoder. In this example, it’s “A serene lake at dusk.”
• We use the text_to_image_generator to generate an image based on the provided description. The max_length parameter controls the maximum length of the generated image’s description, and do_sample=True enables sampling to produce diverse images.
• You can display or save the generated image. The show() function displays the image in the above code snippet.

In this code snippet, the Encoder processes the text description as the Decoder generates an image based on the content of the mentioned text description. This shows us how the Encoders and Decoders work together to transform data from one form (text) into another (image), unlocking creative potential.

The example simplifies the process to illustrate the concept, but real-world applications may involve more complex models and data preprocessing.

Advanced Capabilities

The natural charm of these AI systems lies in their advanced capabilities. They can work with various data types, making them versatile tools for creative endeavors. Let’s delve into some exciting applications:

• Language and Translation: Advanced Encoders can take a sentence in one language, understand its meaning, and then have the Decoders produce the same sentence in another language. It’s like having a multilingual poet at your disposal.
• Art and Style: Encoders can decipher the essence of different art styles, from classic Renaissance to modern abstract, and then Decoders can apply these styles to new artworks. It’s as if an artist can paint in any style they desire.
• Text to Image: An Encoder can understand a textual description, and a Decoder can bring it to life by creating an image based on that description. Think of it as an AI-powered illustrator.
• Voice and Sound: These advanced components are not limited to the visual or textual domain. Encoders can comprehend the emotions in a voice, and Decoders can generate music or speech that conveys those emotions. It’s akin to having a composer who understands feelings.

Enabling Creative Collaboration

One of the most exciting aspects of Encoders and Decoders in Generative AI is their potential to facilitate creative collaboration. These AI systems can understand, translate, and transform creative works across various mediums, bridging gaps between artists, writers, musicians, and more.

Consider an artist’s painting turned into poetry or a musician’s melody transformed into visual art. These are no longer far-fetched dreams but tangible possibilities with advanced Encoders and Decoders. Collaborations that previously seemed improbable now find a path through the language of AI.

Real-time Application of Encoders and Decoders in Generative AI

Real-time applications of Encoders and Decoders in generative AI hold immense potential across diverse domains. These advanced AI components are not confined to theoretical concepts but are actively transforming how we interact with technology. Let’s delve into some real-world use cases:

Language Translation and Chatbots

Encoders decode and encode one language into another, making real-time language translation possible. This technology underpins chatbots that can converse seamlessly in multiple languages, facilitating global communication and customer service.

# Code for Language Translation using Encoders and Decoders
from transformers import pipeline

translator = pipeline("translation", model="Helsinki-NLP/opus-mt-en-fr")
text_to_translate = "Hello, how are you?"
translated_text = translator(text_to_translate, max_length=40)
print(translated_text[0]['translation_text'])

This code utilizes the Hugging Face Transformers library to create a language translation model. An encoder processes the input text (English), and a decoder generates the translated text (French) in real time.

Artistic Creation

Artists use Encoders to extract the essence of a style or genre, and Decoders recreate artwork in that style. This real-time transformation enables rapid art production in various forms, from Renaissance paintings to modern abstract pieces.

# Code for Artistic Creation using Encoders and Decoders
from transformers import pipeline

artist = pipeline("text2image-generation", model="EleutherAI/gpt-neo-2.7B")
text_description = "A serene lake at dusk"
generated_image = artist(text_description, max_length=30, do_sample=True)

This code leverages a text-to-image generation model from the Hugging Face Transformers library. An encoder deciphers the text description, and a decoder generates an image that corresponds to the description, enabling real-time artistic creation.

Content Generation

Encoders analyze text descriptions, and Decoders bring them to life through images, offering practical applications in advertising, e-commerce, and content generation. Transform the real estate listings into immersive visual experiences, and product descriptions can generate corresponding visuals.

# Code for Content Generation using Encoders and Decoders
from transformers import pipeline

content_generator = pipeline("text2text-generation", model="tuner007/pegasus_paraphrase")
input_text = "An elegant villa with a pool"
generated_content = content_generator(input_text, max_length=60, num_return_sequences=3)

This code utilizes a text-to-text generation model from Hugging Face Transformers. The encoder processes a text description, and the decoder generates multiple alternative descriptions for real-time content generation.

Audio and Music Generation

Encoders capture emotional cues in voice, and Decoders generate expressive speech or music in real time. This finds applications in voice assistants, audio content creation, and even mental health support, where AI can provide comforting conversations.

# Code for Basic Audio Generation using Encoders and Decoders
from transformers import pipeline

audio_generator = pipeline("text-to-speech", model="tugstugi/mongolian-speech-tts-ljspeech")
text_to_speak = "Generate audio from text"
generated_audio = audio_generator(text_to_speak)

This code uses a text-to-speech model to convert text into speech (audio). While real-time audio generation is more complex, this simplified example demonstrates using an encoder to interpret the input text and a decoder to generate audio.

Personalized Learning

In education, Encoders and Decoders help create customized learning materials. Textbooks can be converted into interactive lessons with visuals, and language learning apps can provide real-time translation and pronunciation assistance.

# Code for Personalized Learning Recommendations using Encoders and Decoders
from sklearn.decomposition import TruncatedSVD
from sklearn.linear_model import LogisticRegression

# Perform dimensionality reduction with an encoder
encoder = TruncatedSVD(n_components=10)
reduced_data = encoder.fit_transform(student_data)

# Train a personalized learning model with a decoder
decoder = LogisticRegression()
decoder.fit(reduced_data, student_performance)

In personalized learning, an encoder can reduce the dimensionality of student data, and a decoder, in this case, a logistic regression model, can predict student performance based on the reduced data. While this is a simplified example, personalized learning systems are typically much more complex.

Medical Imaging

Encoders can analyze medical images, and Decoders help enhance images or provide real-time feedback. This aids doctors in diagnostics and surgical procedures, offering rapid and accurate insights.

# Code for Basic Medical Image Enhancement using Encoders and Decoders
import cv2

# Read and preprocess the medical image
image = cv2.imread('medical_image.png')
preprocessed_image = preprocess(image)

# Apply image enhancement with a decoder (a sharpening filter)
sharpened_image = apply_sharpening(preprocessed_image)

This code showcases a simple example of medical image enhancement, where an encoder processes and preprocesses the image, and a decoder (sharpening filter) enhances the image quality. Real medical imaging applications involve specialized models and thorough compliance with healthcare standards.

Gaming and Simulations

Real-time interaction with AI-driven characters is possible due to Encoders and Decoders. These characters can adapt, respond, and realistically engage players in video games and training simulations.

# Code for Real-time Interaction in a Text-Based Game
import random

# Decoder function for game characters' responses
def character_response(player_input):
    responses = ["You find a treasure chest.", "A dragon appears!", "You win the game!"]
    return random.choice(responses)

# In-game interaction
player_input = input("What do you do? ")
character_reply = character_response(player_input)
print(character_reply)

While this is a very simplified example, in gaming and simulations, real-time interactions with characters often involve complex AI systems and may not directly use Encoders and Decoders as standalone components.

Conversational Agents

Encoders help machines understand human emotions and context, while Decoders enable them to respond empathetically. This is invaluable in virtual mental health support systems and AI companions for the elderly.

# Code for Basic Rule-Based Chatbot
import random

# Responses Decoder
def chatbot_response(user_input):
    greetings = ["Hello!", "Hi there!", "Greetings!"]
    goodbyes = ["Goodbye!", "See you later!", "Farewell!"]
    user_input = user_input.lower()

    if "hello" in user_input:
        return random.choice(greetings)
    elif "bye" in user_input:
        return random.choice(goodbyes)
    else:
        return "I'm just a simple chatbot. How can I assist you today?"

# Conversational Loop
while True:
    user_input = input("You: ")
    response = chatbot_response(user_input)
    print(f"Chatbot: {response}")

This is a rule-based chatbot, and while it involves encoding user input and decoding responses, complex conversational agents often use sophisticated natural language understanding models for empathy and context-aware replies.

These real-time applications highlight the transformative impact of Encoders and Decoders in generative AI, transcending mere theory to enrich our daily lives in remarkable ways.

Exploring Advanced Encoders and Decoders

BERT (Bidirectional Encoder Representations from Transformers)

BERT is an encoder model used for understanding language. It’s bidirectional, which means it considers both the left and right context of words in a sentence. This deep bidirectional training allows BERT to understand the context of words. For example, it can be figured out that “bank” refers to a financial institution in the sentence “I went to the bank” and a river bank in “I sat by the bank.” It’s trained on a massive amount of text data, learning to predict missing words in sentences.

• Encoder: BERT’s encoder is bidirectional, meaning it considers both a word’s left and right context in a sentence. This deep bidirectional training allows it to understand the context of words, making it exceptionally adept at various natural language understanding tasks.
• Decoder: While BERT is primarily an encoder, it’s often combined with other decoders in tasks like text generation and language translation. Decoders for BERT-based models can be autoregressive or, in some cases, another transformer decoder.

# BERT Encoder
from transformers import BertTokenizer, BertModel

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

input_text = "Your input text goes here"
input_ids = tokenizer(input_text, return_tensors='pt').input_ids
outputs = model(input_ids)
encoder_output = outputs.last_hidden_state

This code uses the Hugging Face transformers library to load a pre-trained BERT model for encoding text. It tokenizes the input text, converts it to input IDs, and then passes it through the BERT model. The encoder_output contains the encoded representations of the input text.

GPT (Generative Pre-trained Transformer)

GPT models are decoders that generate human-like text. They work by predicting the next word in a sequence based on the context of previous words. For example, if the previous words are “The sky is,” GPT can predict the next word might be “blue.” They’re trained on large text corpora to learn grammar, style, and context.

• Encoder: GPT models focus on the decoder aspect, generating human-like text. However, GPT’s decoder can also serve as an encoder by reversing its language model, enabling it to extract information from text effectively.
• Decoder: The decoder aspect of GPT is what makes it fascinating. It generates text autoregressively, predicting the next word based on the context of the previous words. The output is coherent and contextually relevant text.

# GPT Decoder
from transformers import GPT2LMHeadModel, GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
model = GPT2LMHeadModel.from_pretrained('gpt2')

input_text = "Your input text goes here"
input_ids = tokenizer(input_text, return_tensors='pt').input_ids
output = model.generate(input_ids, max_length=50, num_return_sequences=1)

decoded_text = tokenizer.decode(output[0], skip_special_tokens=True)

This code uses Hugging Face’s transformers library to load a pre-trained GPT-2 model for text generation. It takes an input text, tokenizes it, and generates text autoregressively using the GPT-2 model.

VAE (Variational Autoencoder)

VAEs are used for image and text generation. The encoder maps input data into a continuous latent space, a lower-dimensional representation. For example, it can map images of cats into points in this space. The decoder then generates images from these points. During training, VAEs aim to make this latent space smooth and continuous to generate diverse and realistic images.

• Encoder: VAEs are commonly used in image and text generation. The encoder maps input data into a continuous latent space, especially useful for generating diverse, realistic images and texts.
• Decoder: The decoder maps points in the latent space back into data space. It generates images or text from sampled points in the latent space.

# VAE Encoder
import tensorflow as tf
from tensorflow.keras import layers, models

latent_dim = 32  # Dimension of the latent space
input_shape = (128, 128, 3)  # Input image shape

# Define the encoder model
encoder_input = tf.keras.Input(shape=input_shape, name='encoder_input')
x = layers.Flatten()(encoder_input)
x = layers.Dense(256, activation='relu')(x)

# Encoder outputs
z_mean = layers.Dense(latent_dim, name='z_mean')(x)
z_log_var = layers.Dense(latent_dim, name='z_log_var')(x)

encoder = models.Model(encoder_input, [z_mean, z_log_var], name='encoder')

# VAE Decoder
# Define the decoder model
latent_inputs = tf.keras.Input(shape=(latent_dim,), name='z_sampling')
x = layers.Dense(64, activation='relu')(latent_inputs)
x = layers.Dense(256, activation='relu')(x)
x = layers.Reshape((8, 8, 4))(x)
x = layers.Conv2DTranspose(32, 3, activation='relu')(x)

decoder_outputs = layers.Conv2DTranspose(3, 3, activation='sigmoid')(x)

decoder = models.Model(latent_inputs, decoder_outputs, name='decoder')

This code defines a Variational Autoencoder (VAE) in TensorFlow/Keras. The encoder takes an input image, flattens it, and maps it to a latent space with mean and log variance. The decoder takes a point from the latent space and reconstructs the image.

LSTM (Long Short-Term Memory)

LSTMs are recurrent neural networks used for sequential data. They encode sequential data like sentences by considering the context of previous elements in the sequence. They learn patterns in sequences, making them suitable for tasks like natural language processing. In autoencoders, LSTMs reduce sequences to lower-dimensional representations and decode them.

• Encoder: LSTM is a recurrent neural network (RNN) type widely used for various sequential data tasks, such as natural language processing. The LSTM cell encodes sequential data by considering the context of previous elements in the sequence.
• Decoder: While LSTMs are more often used as encoders, they can also be paired with another LSTM or fully connected layers to function as a decoder for generating sequences.

import tensorflow as tf
from tensorflow.keras.layers import LSTM, Dense, Input

# LSTM Encoder
input_seq = Input(shape=(timesteps, input_dim))
encoder_lstm = LSTM(latent_dim)(input_seq)

# LSTM Decoder
decoder_input = Input(shape=(latent_dim,))
decoder_lstm = LSTM(input_dim, return_sequences=True)(decoder_input)

# Autoencoder Model
autoencoder = tf.keras.Model(input_seq, decoder_lstm)

This code sets up a simple LSTM autoencoder. The encoder processes sequences and reduces them to a lower-dimensional representation while the decoder reconstructs sequences from the encoded representation.

CNN (Convolutional Neural Network)

CNNs are primarily used for image analysis. They work as encoders by analyzing images through convolutional layers, capturing features like edges, shapes, and textures. These features can be sent to a decoder, like a GAN, to generate new images. CNNs are trained to recognize patterns and features in images.

• Encoder: CNNs are primarily used in computer vision tasks as encoders. They analyze images by convolving filters over the input, capturing features at different scales. The extracted features can be fed to a decoder for tasks like image generation.
• Decoder: In image generation, CNNs can be followed by a decoder, such as a generative adversarial network (GAN) decoder, to synthesize images based on learned features.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, Flatten, Dense

# CNN Encoder
encoder = Sequential()
encoder.add(Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)))
encoder.add(Conv2D(64, (3, 3), activation='relu'))
encoder.add(Flatten())

# CNN Decoder
decoder = Sequential()
decoder.add(Dense(32 * 32 * 64, input_dim=latent_dim, activation='relu'))
decoder.add(Reshape((32, 32, 64)))
decoder.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
decoder.add(Conv2D(3, (3, 3), activation='sigmoid', padding='same'))

This code defines a simple Convolutional Neural Network (CNN) encoder and decoder using Keras. The encoder processes images through convolutional layers, and the decoder reconstructs images from the encoded representation.

These advanced encoder and decoder models represent the backbone of many generative AI applications. Their flexibility and adaptability have allowed researchers and developers to push the boundaries of what’s achievable in natural language processing, computer vision, and various other fields. As AI continues to evolve, these models will remain at the forefront of innovation.

These models undergo extensive training on large datasets to learn the nuances of their respective tasks. They are fine-tuned to perform specific functions and are at the forefront of AI innovation.

Case Studies of Advanced Encoders and Decoders

BERT in Search Engines

• Google uses BERT to improve its search engine results. BERT helps better to understand the context and intent behind search queries. For instance, if you search for “2019 Brazil traveler to USA need a visa,” traditional search engines might have focused on the keyword “visa.” But with BERT, Google understands that the user is looking for information about a Brazilian traveling to the USA and their visa requirements.
• Google’s BERT-based model for search can be demonstrated using the Hugging Face Transformers library. This code shows how to use a BERT-based model to improve search query understanding:

from transformers import BertTokenizer, BertForQuestionAnswering

tokenizer = BertTokenizer.from_pretrained("bert-large-uncased-whole-
word-masking-finetuned-squad")
model = BertForQuestionAnswering.from_pretrained("bert-large-uncased-
whole-word-masking-finetuned-squad")

question = "How does BERT improve search?"
passage = "BERT helps search engines understand the context and 
intent behind queries, providing more accurate results."

inputs = tokenizer(question, passage, return_tensors="pt")
start_positions, end_positions = model(**inputs)

answer = tokenizer.decode(inputs["input_ids"][0]
[start_positions[0]:end_positions[0]+1])
print("Answer:", answer)

This code uses BERT to enhance search results by understanding user queries and document context, resulting in more accurate answers.

GPT-3 in Content Generation

• Use OpenAI’s GPT-3 to generate content for various applications. It can write articles, answer questions, and even create conversational agents. Companies use GPT-3 to automate content generation, customer support, and virtual assistants.
• OpenAI’s GPT-3 can generate text for various applications. Below is an example of using the OpenAI GPT-3 API for content generation:

import openai

openai.api_key = "YOUR_API_KEY"
prompt = "Write a summary of the impact of AI on healthcare."
response = openai.Completion.create(
    engine="davinci",
    prompt=prompt,
    max_tokens=100
)

generated_text = response.choices[0].text
print("Generated Text:", generated_text)

With GPT-3, you can generate human-like text for tasks like content creation or chatbots by using the OpenAI API.

VAEs in Image Generation

• VAEs have applications in image generation for fashion. Companies like Stitch Fix use VAEs to create personalized clothing recommendations for users. By learning the style preferences of users, they can generate images of clothing items that are likely to be of interest.
• Using VAEs for image generation can be showcased with code that generates new images based on user preferences, similar to what Stitch Fix does.

# Sample code to generate clothing images using VAE
# Assume you have a pre-trained VAE model

user_style_preference = [0.2, 0.7, 0.1]  # Sample user preferences for style
latent_space_sample = generate_latent_sample(user_style_preference)  

generated_image = vae_decoder(latent_space_sample)
display(generated_image)

This code snippet illustrates how Variational Autoencoders (VAEs) can create images based on user preferences, similar to how Stitch Fix suggests clothing based on style preferences.

LSTMs in Speech Recognition

• Speech recognition systems, like those used by Amazon’s Alexa or Apple’s Siri, often utilize LSTMs. They process audio data and convert it into text. These models must consider previous sounds’ context to transcribe speech accurately.
• LSTMs are commonly used in speech recognition. Below is a simplified example of using an LSTM-based model for speech recognition:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(64, input_shape=(100, 13)))
model.add(Dense(10, activation='softmax'))

# Compile and train the model on your dataset

This code sets up an LSTM-based speech recognition model, a fundamental voice assistants and transcription services technology.

CNNs in Autonomous Vehicles

• Autonomous vehicles rely on CNNs for real-time image analysis. They can identify objects like pedestrians, other vehicles, and traffic signs. This is essential for making split-second decisions in driving.
• Autonomous vehicles rely on CNNs for object detection. Here’s a simplified example of using a pre-trained CNN model for object detection:

from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions

model = MobileNetV2(weights='imagenet')
img_path = 'car.jpg'  # Your image path
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = preprocess_input(x)
x = np.expand_dims(x, axis=0)

predictions = model.predict(x)
decoded_predictions = decode_predictions(predictions, top=3)[0]
print(decoded_predictions)

In the context of autonomous vehicles, CNNs, like MobileNetV2, can detect objects in images to help self-driving cars make decisions on the road.

These code snippets provide a practical demonstration of how to apply these AI techniques in various real-world scenarios. Please note that real-world implementations are often more complex and use extensive datasets, but these examples offer a simplified view of their application.

Ethical and Responsible Use

As with any powerful tool, the ethical use of advanced Encoders and Decoders is paramount. Ensuring that AI-generated content respects copyright, maintains privacy, and doesn’t propagate harmful or offensive material is vital. Moreover, accountability and transparency in the creative process are key, mainly when AI plays a significant role.

Conclusion

The fusion of advanced Encoders and Decoders in Generative AI marks a new era of creativity, where the boundaries between different forms of art and communication blur. Whether translating languages, recreating art styles, or converting text into images, these AI components are the keys to unlocking innovative, collaborative, and ethically responsible creativity. With responsible usage, they can reshape how we perceive and express our world.

Key Takeaways

• Encoders and Decoders in Generative AI are transforming how we create, interpret, and interact with art, language, and data.
• These AI components play essential roles in understanding and generating various forms of data, including text, images, and audio.
• Real-time applications of Encoders and Decoders span language translation, art generation, content creation, audio generation, personalized learning, medical imaging, gaming, and conversational agents.
• Ethical and responsible usage of AI-generated content is crucial, focusing on privacy, transparency, and accountability.

Frequently Asked Questions

The media shown in this article is not owned by Analytics Vidhya and is used at the Author’s discretion.