Generative AI using Python - Basic
Interview Questions with Answers

41. What are the key evaluation metrics for generative models (FID, IS, BLEU, ROUGE)?

Answer:

Example to calculate BLEU:

from nltk.translate.bleu_score import sentence_bleu
reference = [["this", "is", "a", "test"]]
candidate = ["this", "is", "test"]
score = sentence_bleu(reference, candidate)
print(score)

42. How do you handle overfitting in generative models?

Answer:
To handle overfitting in generative models:

1. Early Stopping – Stop training when validation loss increases.
2. Regularization – Use dropout or weight decay.
3. Data Augmentation – Increase training variety.
4. Latent Noise Injection – Adds variation in GANs.
5. Reduce Model Complexity – Use fewer layers or parameters.
6. Train with More Data – Improves generalization.

Example: Early stopping in Keras:

from tensorflow.keras.callbacks import EarlyStopping
callback = EarlyStopping(monitor='val_loss', patience=5)
model.fit(X_train, y_train, validation_split=0.2, callbacks=[callback])

43. What are the best practices to tune hyperparameters in GAN training?

Answer:
Best practices include:

• Use separate learning rates for Generator and Discriminator (e.g., 1e-4 for G, 4e-4 for D).
• Use Batch Normalization in Generator.
• Avoid Batch Norm in Discriminator.
• Use LeakyReLU in Discriminator.
• Label smoothing (e.g., real = 0.9) for stability.
• Avoid training D too well (it may overpower G).

Example: (PyTorch Optimizers)

optimizer_G = torch.optim.Adam(generator.parameters(), lr=0.0001)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0004)

44. Implement early stopping for a GAN using custom training loops.

Answer:
Early stopping can be manually tracked in GANs since custom loops are common.

best_loss = float("inf")
epochs_no_improve = 0
patience = 5
for epoch in range(num_epochs):
    train_gan()  # Custom GAN training per epoch
    if validation_loss < best_loss:
        best_loss = validation_loss
        epochs_no_improve = 0
    else:
        epochs_no_improve += 1
    if epochs_no_improve == patience:
        print("Early stopping triggered")
        break

Use a validation metric like discriminator loss on real images.

45. How do you use TensorBoard to track GAN training progress in Python?

Answer:
TensorBoard helps visualize losses and images.

Steps:

1. Create a TensorBoard log directory.
2. Use tf.summary.scalar() and tf.summary.image() for logging.
3. Launch TensorBoard with tensorboard –logdir logs/.

Example:

import tensorflow as tf
writer = tf.summary.create_file_writer("logs/gan")
with writer.as_default():
    tf.summary.scalar("generator_loss", gen_loss, step=epoch)
    tf.summary.scalar("discriminator_loss", disc_loss, step=epoch)

46. How do you perform data augmentation to improve generative model performance?

Answer:
Data augmentation increases input diversity, which helps the model generalize better.

Common augmentations:

• Flip (horizontal/vertical)
• Rotation
• Color jitter
• Noise injection

Example using PyTorch:

from torchvision import transforms
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(15),
    transforms.ToTensor()
])

For text: paraphrasing, synonym replacement, back translation.

47. What is Wasserstein GAN (WGAN) and how does it improve training stability?

Answer:
WGAN is a variant of GAN that improves training by:

• Replacing binary cross-entropy loss with Wasserstein distance (a smooth measure of difference between distributions).
• Removes the problem of vanishing gradients in standard GANs.
• Uses a critic instead of discriminator and removes sigmoid.

Key Features:

• Weight clipping or gradient penalty
• Better convergence

Loss Function (simplified):

# Critic loss

loss_D = -torch.mean(real_output) + torch.mean(fake_output)

# Generator loss

loss_G = -torch.mean(fake_output)

48. Write Python code to visualize generated samples after each epoch.

Answer:

import matplotlib.pyplot as plt
def show_generated_images(generator, epoch, latent_dim=100, n=5):
    noise = torch.randn(n, latent_dim).to(device)
    fake_images = generator(noise).detach().cpu()
    plt.figure(figsize=(n, 1))
    for i in range(n):
        plt.subplot(1, n, i + 1)
        plt.imshow(fake_images[i].permute(1, 2, 0).squeeze(), cmap='gray')
        plt.axis('off')
    plt.suptitle(f"Epoch {epoch}")
    plt.show()

Call this function at the end of every epoch in GAN training loop.

49. How do you apply transfer learning to improve generative model performance?

Answer:
Transfer learning in generative models means:

• Reusing pre-trained models (like GPT, StyleGAN).
• Fine-tuning on a smaller domain-specific dataset.

Use cases:

• Train GPT-2 on medical data for domain-specific generation.
• Fine-tune Stable Diffusion on custom art styles (DreamBooth).

Example (using Transformers):

from transformers import GPT2LMHeadModel
model = GPT2LMHeadModel.from_pretrained("gpt2")
model.train()  # Fine-tune on your dataset

50. How can you optimize inference time of generative models for real-time applications?

Answer:

Techniques to optimize inference time:

• Model quantization (e.g., float32 → int8)
• Use ONNX or TorchScript for model export
• Use GPU acceleration (CUDA, TensorRT)
• Use batch generation
• Reduce sequence/image size
• Use distilled versions (e.g., DistilGPT2)

Example:

Export to TorchScript
scripted_model = torch.jit.script(model)
torch.jit.save(scripted_model, "model.pt")

51. How do you deploy a generative AI model using FastAPI or Flask?

Answer:
You can deploy a generative AI model using FastAPI or Flask to serve predictions via APIs.

Example using FastAPI:

from fastapi import FastAPI
from transformers import pipeline
app = FastAPI()
generator = pipeline("text-generation", model="gpt2")
@app.get("/generate")
def generate(prompt: str):
    output = generator(prompt, max_length=50)
    return {"result": output[0]['generated_text']}
Run server:
uvicorn app:app --reload

This exposes the model for real-time use via HTTP.

52. What are use cases of Generative AI in content creation and marketing?

Answer:
Generative AI is transforming content creation in:

• Copywriting – Generating product descriptions, emails, headlines.
• Social Media Posts – Creating engaging content for platforms.
• Blog Writing – Auto-generating long-form content with GPT-based tools.
• SEO Optimization – Keyword-rich text generation.
• Image/Ad Design – Using DALL·E or Stable Diffusion to generate ad creatives.
• Video Scriptwriting – Drafting ad scripts automatically.

Tools used:

• Jasper AI
• ChatGPT
• Copy.ai
• Writesonic

53. How would you implement a chatbot using GPT and LangChain in Python?

Answer:
LangChain makes it easy to build GPT-based chatbots.

Steps:

Install:

pip install langchain openai

Example

from langchain.llms import OpenAI
from langchain.chains import ConversationChain
llm = OpenAI(model_name="gpt-3.5-turbo")
chatbot = ConversationChain(llm=llm)
response = chatbot.predict(input="Hi, what's the weather like?")
print(response)
LangChain supports memory, prompt engineering, and chaining tools.

54. What security concerns exist with deploying LLMs and GANs in production?

Answer:
Key security concerns include:

• Misinformation generation – LLMs may hallucinate or output false data.
• Bias and discrimination – Pretrained models may reflect harmful biases.
• Prompt injection attacks – Malicious prompts that override instructions.
• Data leakage – Unintentional reproduction of training data.
• Image misuse – Deepfakes or fake identity generation.

Mitigation:

• Use moderation filters (OpenAI, AWS).
• Limit prompt scope.
• Regularly monitor output and logs.
• Use watermarking in generated images.

55. How do you use Gradio or Streamlit to create a web UI for generative models?

Answer:
Gradio Example:

import gradio as gr
from transformers import pipeline
generator = pipeline("text-generation", model="gpt2")
def generate_text(prompt):
    return generator(prompt, max_length=50)[0]['generated_text']
gr.Interface(fn=generate_text, inputs="text", outputs="text").launch()

Streamlit Example:

import streamlit as st
from transformers import pipeline
st.title("Text Generator")
generator = pipeline("text-generation", model="gpt2")
prompt = st.text_input("Enter prompt:")
if prompt:
    result = generator(prompt, max_length=50)
    st.write(result[0]['generated_text'])

Both tools are great for demoing generative models with a user-friendly GUI.

56. How can you implement a recommendation system enhanced with Generative AI?

Answer:
You can use Generative AI to improve recommendations by:

• Generating personalized product descriptions based on user profiles.
• Generating synthetic user interaction data for model training.
• Using embeddings from LLMs for semantic similarity.

Example

from transformers import AutoTokenizer, AutoModel

import torch

# Get semantic vector of product description

tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
inputs = tokenizer("Wireless noise-cancelling headphones", return_tensors="pt")
embedding = model(**inputs).last_hidden_state.mean(dim=1)

# Use this embedding for similarity-based recommendations

57. Explain how to use Google Colab to train and visualize generative models.

Answer:
Steps to use Google Colab:

1. Go to: https://colab.research.google.com
2. Use free GPU: Runtime > Change runtime type > GPU
3. Train a GAN or GPT model:

!pip install torch torchvision matplotlib

1. Sample code:

import torch
from torchvision.utils import make_grid
import matplotlib.pyplot as plt

# generate fake images from trained GAN

images = generator(torch.randn(64, latent_dim)).detach()
grid = make_grid(images, nrow=8, normalize=True).permute(1, 2, 0)
plt.imshow(grid)
plt.axis('off')
plt.show()

Colab provides GPU acceleration for free (limited hours).

58. How do you handle GPU/TPU memory optimization while training large generative models?

Answer:
Techniques for memory optimization:

• Use torch.cuda.empty_cache() to release memory.
• Use with torch.no_grad() during inference.
• Use mixed-precision training (torch.cuda.amp).
• Reduce batch size or resolution.
• Use gradient checkpointing.

Mixed precision example:

from torch.cuda.amp import GradScaler, autocast
scaler = GradScaler()
for data in dataloader:
    optimizer.zero_grad()
    with autocast():
        output = model(data)
        loss = loss_fn(output, target)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

59. What are ethical concerns around AI-generated content and how do you handle them?

Answer:

Handling:

• Apply content filters.
• Disclose AI involvement.
• Use audit trails and output logging.
• Train on curated, diverse datasets.
• Use AI ethics guidelines (e.g., by Google, UNESCO, OpenAI).

60. Explain how to build a multi-modal application that uses both text and image generation.

Answer:
Multi-modal applications combine text and image generation using models like CLIP, DALL·E, or BLIP.

Steps:

1. Take text input (e.g., prompt from user).
2. Generate image using Stable Diffusion.
3. Generate caption or story using GPT or BLIP.

Example (Text → Image → Text):

# Generate image from text

from diffusers import StableDiffusionPipeline
pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")
image = pipe("A futuristic city at night").images[0]

# Caption the image

from transformers import BlipProcessor, BlipForConditionalGeneration
processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
inputs = processor(images=image, return_tensors="pt")
caption_ids = model.generate(**inputs)
print(processor.decode(caption_ids[0], skip_special_tokens=True))