R18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad 1. Setting up the Spyder IDE Program vironment and Executing a Python AIM: Setting up the Spyder IDE Environment and Executing a Python Program DESCRIPTION: To sct up the Spyder IDE (Integrated Development Environment) and execute a Python program, follow these steps: 1. Install _ | Download and install Python from official website: Python _| hitps://www.python.org/downloads! 2. Install _ | Anaconda, a popular Python distribution for data science, Spyder | includes Spyder and pre-installed packages for scientific computing and analysis. Download from the official website: https://www.anaconda.com/products/individual and follow installation instructions. 3. Launch | Launch Spyder IDE after installing Anaconda. Spyder 4. Create | In Spyder, you can create a new Python file or open an existing or open | one. To create a new file, go to "File" > "New File" or use the a keyboard shorteut CtrHN (Command+N on Mac). Python | Alternatively, you can open an existing Python file by going to file "File" > "Open" or using the keyboard shortcut Ctrl+O (Command+0 on Mac). 5. Write | Write Python code in editor window for simple program. For your —_| example, Python_| print("Hello, World!") code 6. Save the | Save your Python file with the ".py” extension, for example, Python | "hello.py". You can do this by going to "File" > "Save" or file using the keyboard shortcut Ctrl+$ (Command+S on Mac). 7. Execute | To execute your Python program, go to "Run" > "Run" or press the the FS key. The output of your program will appear in the Python | console pane at the bottom of the Spyder IDE. progra m That's it! You have set up the Spyder IDE environment and executed a Python program. You can now continue writing and executing more complex Python code within Spyder.R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad VIVA QUESTIONS: > How can you install Spyder IDE on your computer, and what are the benefits of using Spyder over a standard text editor for Python programming? > How do you execute a Python program in the Spyder IDE, and what are the different ways to run the code?R18 B.Tech. AI@ML = DEEPLEARNINGLAB — JNTU Hyderabad 2. Installing Keras, Tensorflow and Pytorch libraries and making use of them AIM: Installing Keras, Tensorflow and Pytorch libraries and making use of them DESCRIPTION: To install Keras, TensorFlow, and PyTorch libraries and make use of them, you can follow the steps below: 1, Install Ensure Python is installed and download the latest Python and _| version from the official website: pip (ifnot —_| https:/hwww.python.org/downloads/ already Python comes pre-installed with pip; install if installed) unavailable via pip website: hitps://pip.pypa.io/en/stable/installing/ 2. Install Open a command prompt or terminal and run the TensorFlow _ | following command to install TensorFlow using pip: pip install tensorflow 3. Install Keras | Keras integrated into TensorFlow, ensuring automatic installation during installation. However, you can explicitly install Keras using pip: pip install keras 4, Install Install PyTorch by visiting official website, selecting PyToreh appropriate command based on system configuration: https://pytorch.org/get-started/locally/ For example, to install the CPU-only version of PyTorch using pip, you can run: pip install torch torchvision 5. Verify ‘After installing the libraries, you can verify that installations | everything is set up correctly by launching a Python interpreter or creating a Python script and importing the libraries: import tensorflow as tf import keras import torch print(""TensorFlow version:", tf.__version_) print("Keras version:", keras, version) print("PyTorch version:", torch._version_) This code will output the versions of the installed libraries, confirming that everything is installed correctly. 6. Using the Install libraries, use for machine learning models libraries training. Here's a basic é le of how you can create a simpleR18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad neural network using TensorFlow/Keras and PyTorch: > Using TensorFlow/Keras: import tensorflow as tf from tensorflow.keras import layers # Create a simple neural network model = tf-keras.Sequential([ layers.Dense(64, activation='relu’, input_shape-(784,)), layers.Dense(10, activation~'softmax') ) # Compile the model model.compile(optimizer='adam’, loss='sparse_categorical_crossentropy', metrics=['accuracy']) # Train the model (example data used here) # model fit(train_data, train_labels, epochs=10, batch_size=32) > Using PyTorch: import torch import torch.nn as nn import torch.optim as optim # Create a simple neural network class SimpleNet(nn. Module): def __init__(self): super(SimpleNet, self).__init_() self.fel = nn.Linear(784, 64) self.fe2 = nn.Linear(64, 10) def forward(self, x): x= torch.relu(self.fel(x)) x = self. fe2(x) return x model = SimpleNet() # Define loss function and optimizer criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # Train the model (example data used here) # for epoch in range(10) # — running_loss = 0.0 # for data, labels in train_loader: # —— optimizer.zero grad() # outputs = model(data) # loss riterion(outputs, labels)R18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad PS) # —— optimizer.step() # —— running_loss + loss.item() # print(f"Epoch {epoch+1}, Loss: {running loss/len(train_loader)}") In these examples, we've created simple neural network architectures using TensorFlow/Keras and PyTorch, but you can build more complex models depending on your specific tasks and requirements. VIVA QUESTIONS: > How can you install Keras, TensorFlow, and PyTorch libraries on your system, and what are the differences between these deep learning frameworks? > Explain the process of building a simple neural network using Keras for image classification, and how do you compile and train the model?R18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad 3. Applying the Convolution Neural Network on computer vision problems AIM: Applying the Convolution Neural Network on computer vision problems DESCRIPTION CNNs (Convolutional Neural Networks) revolutionize computer vision by learning spatial hierarchies automatically. Here are some common computer vision problems where CNNs are frequently used: Image Image classification involves assigning a label or category to Classificatio an input image from a predefined set of classes. CNNs excel n at this task due to their ability to learn hierarchical features and capture patterns in images. Object Object detection involves identifying and localizing multiple Detection _| objects of interest within an image. CNNs can be combined with techniques like Region Proposal Networks (RPNs) or Single Shot Multibox Detector (SSD) to accomplish object | detection tasks. Semantic | Semantic segmentation involves classifying each pixel of an Segmentatio | image into a specific category. CNNs with fully n convolutional architectures, such as U-Net or DeepLab, are commonly used for semantic segmentation. Instance Instance segmentation goes beyond semantic segmentation Segmentatio | by not only classifying cach pixel but also distinguishing n individual object instances. CNNs, combined with methods like Mask R-CNN, are often used for instance segmentation tasks. Image CNNs can be used for image generation tasks, such as Generation | generating realistic images from scratch. Generative Adversarial Networks (GANs) and Variational Autoencoders _(VAEs) are popular architectures for image synthesis. Style Style transfer involves transferring the visual style of one Transfer image to another while preserving the content. CNNs are used to separate and manipulate the content and style | representations of the images. Image Image captioning combines computer vision and natural Captioning _| language processing to generate textual descriptions forR18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad input images. CNNS are used to extract visual features, which are then combined with recurrent neural networks (RNNS) to generate captions. Super- ‘Super-resolution aims to upscale low-resolution images to Resolution higher resolutions. CNNs, particularly architectures like SRGAN (Super-Resolution Generative Adversarial Network), are commonly used for super-resolution tasks. Face CNNs have demonstrated remarkable performance in face Recognition _ recognition tasks, where the goal is to identify individuals based on their facial features. Image CNNS can be applied to remove noise, artifacts, or restore Denoising damaged images, making them useful in image denoising and and restoration tasks. Restoration To apply CNNs to these computer vision problems, you'll need labeled datasets for training, and you'll build and train CNN architectures using popular deep learning libraries like TensorFlow, Keras, or PyTorch. The specific architecture and training process will vary depending on the problem at hand. It's also common to use pre-trained CNN models (¢.g., VGG, ResNet, MobileNet) and fine-tune them on specific tasks if you have limited data. Overall, CNNs have revolutionized computer vision and continue to advance the state-of-the-art in a wide range of applications, bringing significant improvements to the accuracy and robustness of computer vision systems. VIVA QUESTIONS: > What is the main advantage of using Convolutional Neural Networks (CNNs) over traditional fully connected neural networks for computer vision tasks? > Explain the typical architecture of a Convolutional Neural Network used for image classification, and what are the functions of different layers in this architecture?R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad 4, Image classification on MNIST dataset (CNN model with Fully connected layer) AIM: Image classification on MNIST dataset (CNN model with Fully connected layer) DESCRIPTION: Image classification on the MNIST dataset is a classic example and a great starting point for understanding how to build a Convolutional Neural Network (CNN) with a Fully Connected Layer for image recognition. The MNIST dataset consists of 28x28 grayscale images of handwritten digits from 0 to 9. Each image is associated with a label representing the digit it represents. Here's a step-by-step guide to building a CNN model with a Fully Connected Layer for image classification on the MNIST dataset using TensorFlow and Keras: Step 1: Import the necessary libraries import numpy as np import tensorflow as tf from tensorflow.keras import layers, models, datasets Step 2: Load and preprocess the MNIST dataset # Load MNIST dataset (train_images, train_labels), (test_images, test_labels) = datascts.mnist.load_data() # Normalize pixel values to range [0, 1] train_images, test_images = train_images / 255.0, test_images / 255.0 # Expand dimensions to add channel dimen sion (for grayscale images) train_images = np.expand_dims(train_images, axis=-1) test_images = np.expand_dims(test_images, axis=-1) Step 3: Build the CNN modelR18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad model = models.Sequential() # Convolutional layers model.add(layers.Conv2D(32, (3, 3), activation='relu’, input_shape=(28, 28, 1))) model.add(layers. MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu’)) model.add (layers. MaxPooling2D(2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu’)) # Flatten the 3D output to ID model.add(layers.Flatten)) # Fully Connected layers model.add(layers.Dense(64, activation='relu’)) model.add(layers.Dense(10, activation='softmax’)) # 10 output classes (0-9 digits) Step 4: Compile the model model.compile(optimizer—'adam’, loss='sparse_categorical_crossentropy’, metries=['accuracy']) Step 5: Train the model model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.1) Step 6: Evaluate the model on the test set test_loss, test_accuracy = model.evaluate(test_images, test_labels) print("Test accuracy:", test_accuracy) Step 7: Make predictions on new data odel.predict(test_imag SD) predicted_labels = np.argmax(predictions, axis=1) predictions print("Predicted labels:", predicted_labels) print(""True labels:", test_labelsf:5])R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad This code will create a CNN model with three convolutional layers followed by a fully connected layer. It will then train the model on the MNIST dataset and evaluate its accuracy on the test set. Finally, it will make predictions on five test images and display the predicted labels along with the true labels. You can experiment with the number of layers, units, and other hyperparameters to improve the model's performance. Additionally, you can use techniques like data augmentation and dropout to further enhance the model's generalization capabilities. VIVA QUESTIONS: > What is the MNIST dataset, and why image classification models? > Describe the architecture of a CNN model with a fully connected layer for image classification on the MNIST dataset. it commonly used for testingR18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad 5. Applying the Deep Learning Models in the field of Natural Language Processing AIM: Applying the Deep Learning Models in the field of Natural Language Processing DESCRIPTION: Deep learning models have made significant contributions to the field of Natural Language Processing (NLP), enabling the development of powerful language models and applications. Some of the key deep learning models used in NLP include: Recurrent Neural Networks (RNNS): RNNS are designed to handle sequential data, making them well-suited for natural language processing tasks where the order of words matters. They process input data step-by-step while maintaining hidden states to capture context. However, traditional RNNs suffer from vanishing gradient problems. Long Short-Term Memory (LSTM) and Gated Recurrent Unit (GRU) are popular variants of RNNs that address this issue. Applications: Text Sentiment Named Entity | Language classification analysis Recognition modeling (NER) Transformers: Transformers introduced the attention mechanism, enabling more efficient and parallelized processing of sequential data. They have revolutionized NLP by capturing long-range dependencies effectively and have become the backbone of modem language models. Applications: Machine Translation (e.g., | Text generation Question-Answering Google's Transformer (e-g., OpenAl's GPT | (e.g., Google's BERT- based model "BERT" for _| series) based model "BERT" for NMT) QA) Bidirectional Encoder Representations from Transformers (BERT): BERT is a transformer-based language model pre-trained on a large corpus of text data. It learns contextualized word representations, allowing it to understand the context in which a word . in a sentence. BERT's pre-R18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad trained representations can be fine-tuned for a wide range of NLP tasks, making it a versatile and powerful model. Applications: Text Named Entity | Sentiment Question- classification Recognition analysis Answering (NER) Generative Pre-trained Transformer (GPT GPT is a family of transformer-based language models developed by OpenAl. GPT-3, in particular, is one of the largest language models ever created, with 175 billion parameters. It demonstrates impressive capabilities in natural language understanding and generation. Applications: Text completion Text generation (e.g, | Language translation creative writing, code generation) Convolutional Neural Networks for NLP: Although more commonly used for computer vision, CNNs can be adapted to NLP tasks. They are often employed for text classification and sentiment analysis by treating text as a 1D sequence of tokens. Applications: Text classification Sentiment analysis Sequence-to-Sequence Models: Sequence-to-sequence models use encoder-decoder architectures to handle tasks that involve transforming one sequence into another, such as machine translation and summarization. Applications: Machine translation Text summarization Attention Mechanisms: Attention mechanisms are not models themselves, but they have been instrumental in improving the performance of various NLP models. They allow models to focus on specific parts of the input during processing, enhancing their understanding and performance. Applications: Language translation eo generation ]R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad These deep learning models, along with their variants and combinations, have driven significant advancements in the field of Natural Language Processing, enabling the development of more sophisticated and context-aware language models and applications. As research progresses, we can expect further improvements and innovations in NLP, ultimately leading to more accurate and human-like language processing systems. VIVA QUESTIONS: > What is the role of Word Embeddings in Natural Language Processing, and how do they benefit deep learning models for NLP tasks? > How do Recurrent Neural Networks (RNNs) handle sequential data in Natural Language Processing, and what are some of the challenges they face?R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad 6. Train a sentiment analysis model on IMDB dataset, use RNN layers with LSTM/GRU notes AIM: Train a sentiment analysis model on IMDB dataset, use RNN layers with LSTM/GRU notes To train a sentiment analysis model on the IMDB dataset using RNN layers with LSTM/GRU units, we'll use TensorFlow and Keras. The IMDB dataset contains movie reviews labeled as positive or negative sentiments. Step 1: Import the necessary libraries. import tensorflow as tf from tensorflow.keras.datasets import imdb from tensorflow.keras.preprocessing. sequence import pad_sequences from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Embedding, LSTM, GRU, Dense Step 2: Load and preprocess the IMDB dataset. # Load the IMDB dataset, keeping only the top 10,000 most frequent words num_words = 10000 (train_data, train_labels), (test_data, test_labels) = imdb.Joad_data(num_words-num_words) # Pad the sequences to ensure they all have the same length max_length = 250 train_data = pad_sequences(train_data, maxlen=max_length) test_data = pad_sequences(test_data, maxlen=max_length) Step 3: Build the RNN model with LSTM or GRU layers. embedding_dim = 100 model = Sequential() model.add(Embedding(input_dim=num_words, output_dim=embedding_dim, input_length=max_length)) # Choose LSTM or GRU layer #LSTM Layer # model.add(LSTM(units=64, dropout=0.2, recurrent_dropout=0.2)) # GRU Layer model.add(GRU(units=64, dropout=0.2, recurrent_dropout=0.2)) model.add(Dense(units=1, activation="sigmoid’)) Step 4: Compile and train the model. model.compile(optimizer='adam', loss='binary_crossentropy’, ccuracy']) batch_size = 128 aR18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad epochs = 5 model.fit(train_data, train_labels, batch_size=batch_size, epochs=epochs, validation_split=0.2) Step 5: Evaluate the model on the test set. test_loss, test_accuracy = model.evaluate(test_data, test_labels) print("Test accuracy:", test_accuracy) That's it! With these steps, you have built and trained a sentiment analysis model on the IMDB dataset using RNN layers with LSTM/GRU units. The model will learn to predict whether movie reviews are positive or negative based on the given text. You can experiment with different hyperparameters, such as the number of LSTM/GRU units, the embedding dimension, or the number of epochs, to see how they affect the model's performance. VIVA QUESTIONS: > What is the IMDB dataset, and what is the goal of training a sentiment analysis model on this dataset using RNN layers with LSTM/GRU? > Explain the role of LSTM/GRU units in the sentiment analysis model and how they address the vanishing gradient problem in traditional RNNs?R18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad 7. Applying the Autoencoder algorithms for encoding the real-world data AIM: Applying the Autoencoder algorithms for encoding the real-world data DESCRIPTION: Autoencoders are a class of neural network architectures used for unsupervised learning. They are particularly useful for encoding real-world data into a lower- dimensional representation, also known as the "latent space" or "encoding space." Autoencoders consist of two main parts: the encoder, which maps the input data to the latent space, and the decoder, which reconstructs the data from the encoded representation. The objective is to minimize the difference between the original input and the reconstructed output, encouraging the model to learn a compact representation of the data. Applying Autoencoders for encoding real-world data involves the following steps: Step 1: Data Preparation Collect and preprocess the real-world data you want to encode. Ensure that the data is in a suitable format and normalize it if necessary. Step 2: Build the Autoencoder Model Create the Autoencoder model using a neural network library like TensorFlow or Keras. import tensorflow as tf from tensorflow.keras.layers import Input, Dense from tensorflow.keras.models import Model # Define the input size input_size = # Define the size of the latent space (encoded representation) latent_dim = # Encoder input_data = Input(shape=(input_size,)) encoded = Dense(latent_dim, activation—'relu')(input_data) # Decoder decoded = Dense(input, # Autoencoder model autoencoder = Model(input_data, decoded) e, activation='sigmoid’)(encoded) Step 3: Compile and Train the Autoencoder Compile the model with an appropriate optimizer and loss function, and then train the Autoencoder on your real-world data. autoencoder.compile(optimizer='adam’, loss='mean_squared_error') # Assuming you have your data aR18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad autoencoder.fit(data, data, epochs=50, batch_size=32) Step 4: Encode Real-World Data Once the Autoencoder is trained, you can use the encoder part of the model to encode your real-world data into the latent space. encoder = Model(input_data, encoded) encoded_data = encoder.predict(data) The encoded_data variable now contains the encoded representation of your real-world data in the lower-dimensional latent space. Step 5: Decode Encoded Data (Optional) If desired, you can use the decoder part of the model to reconstruct the data from the encoded representation. # Assuming you have the encoder part of the model stored in ‘encoder! decoder_input = Input(shape=(latent_dim,)) decoded_output = autoencoder.layers[-1](decoder_input) # Get the last layer of the decoder decoder = Model(decoder_input, decoded_output) # Reconstruct data from encoded representation reconstructed_data = decoder.predict(encoded_data) Autoencoders are powerful tools for dimensionality reduction and feature earning in real-world data. They are widely used in various applications, including anomaly detection, data compression, and denoising. By training an Autoencoder, you can obtain a more compact representation of your data, which can be useful for downstream tasks or visualizations VIVA QUESTIONS: > What is the main purpose of using autoencoder algorithms in encoding real-world data, and how do they work? > Explain the typical architecture of an autoencoder model, and what are some popular variations of autoencoders used for different real- world data encoding tasks?R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad 8. Applying Generative Adversial Networks for image generation and unsupervised tasks, AIM: Applying Generative Adversial Networks for image generation and unsupervised tasks. DESCRIPTION: Generative Adversarial Networks (GANs) are a powerful class of deep learning models used for various tasks, including image generation and unsupervised learning. GANs consist of two neural networks: a generator and a discriminator. The generator generates fake data (c.g., images), while the discriminator tries to distinguish between real data and fake data generated by the generator. The two networks are trained simultaneously in a competition, where the generator tries to produce data that fools the discriminator, and the discriminator tries to get better at distinguishing real from fake data. Here's how GANs can be applied for image generation and unsupervised tasks: Image Generation with GANs: The primary application of GANs is image generation. The generator learns to create new images that resemble the training data. The discriminator provides feedback to the generator, guiding it to produce more realistic images over time. Step 1: Import the necessary libraries. import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dense, LeakyReLU, BatchNormalization, Reshape, Conv2DTranspose, Conv2D, Flatten from tensorflow.keras.models import Sequential Step 2: Build the Generator and Discriminator models. def build_generator(latent_dim): model = Sequential() model.add(Dense(256, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.01)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.01)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(1024)) model.add(LeakyReLU(alpha=0.01)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(28 * 28 * 1, activation~'tanh’)) model.add(Reshape((28, 28, 1))) aR18 B.Tech. AI&ML DEEP LEARNING LAB IJNTU Hyderabad return model def build_discriminator(img_shape): model = Sequential() model.add(Flatten(input_shape=img_shape)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.01)) model.add(Dense(256)) model.add(LeakyReLU(alpha=0.01)) model.add(Dense(1, activation='sigmoid’)) return model Step 3: Define the GAN model by combining the Generator and Discriminator. def build_gan(generator, discriminator): discriminator.trainable = False model = Sequential() model.add(generator) model.add(discriminator) return model Step 4: Train the GAN model. # Define hyperparameters latent_dim = 100 img_shape = (28, 28, 1) # Build and compile the discriminator and generator generator = build_generator(latent_dim) discriminator = build_discriminator(img_shape) gan = build_gan(generator, discriminator) discriminator.compile(loss="binary_crossentropy', optimizer—tf.keras.optimizers.Adam(0.0002, 0.5)) gan.compile(loss='binary_crossentropy’, optimizer=tf.keras.optimizers.Adam(0.0002, 0.5)) # Load and preprocess real image data (e.g., from MNIST dataset) # Training loop batch_size = 64 half_batch = batch_size // 2 for epoch in range(epochs): # Train the discriminator idx = np.random.randint(0, “ half_batch)R18 B.Tech. AI&ML DEEP LEARNING LAB JNTU Hyderabad real_images = X_train[idx] noise = np.random.normal(0, 1, (half_batch, latent_dim)) generated_images = generator.predict(noise) 4 _loss_real = diseriminator.train_on_batch(real_images, np.ones((half_batch, by) d_loss_fake = discriminator:train_on_batch(generated_images, np.zeros((half_batch, 1))) 4 loss = 0.5 * np.add(d_oss_real, d_loss_fake) # Train the generator noise = np.random.normal(0, 1, (batch_size, latent_dim)) valid_labels = np.ones((bateh_size, 1)) g loss = gan.train_on_batch(noise, valid_labels) Unsupervised Tasks with GANs: GANS can be used for various unsupervised learning tasks, such as data augmentation, feature extraction, and anomaly detection. For example, a pre- trained GAN generator can be used to generate additional data for training purposes, which can improve the performance of other models. GANs can also be used for feature extraction by using the intermediate layers of the generator as feature representations for downstream tasks. In summary, GANs are versatile models that have proven to be effective in image generation and unsupervised learning tasks. They have a wide range of applications and continue to be an active area of research in the deep learning community. VIVA QUESTIONS: > How do Generative Adversarial Networks (GANs) work for image generation, and what are the main components of a GAN model? > How can GANs be applied to unsupervised tasks, and what are some examples of unsupervised learning tasks where GANs have been successfully used?