🎨 Image Generative AI Using Deep Learning & Diffusion Models

A production-ready, beginner-friendly text-to-image generation system powered by Stable Diffusion, Hugging Face Diffusers, and FastAPI.

---

📌 Table of Contents

• Introduction
• Features
• Architecture
• Folder Structure
• Installation
• Running the Application
• API Endpoints
• Frontend Usage
• Deployment
• Troubleshooting

---

🧠 Introduction

This project implements a Text-to-Image Generative AI system using Stable Diffusion and the Hugging Face Diffusers library. Users can enter a natural language prompt (e.g., "a futuristic city at night, neon lights, cyberpunk style") and the system generates a high-quality image using the diffusion model pipeline.

The system is built with:

• Backend: Python + FastAPI
• Frontend: HTML5 + CSS3 + JavaScript (Vanilla)
• AI Model: Stable Diffusion v2.1 via Hugging Face
• Deployment: Docker, AWS EC2 / Google Cloud / Hugging Face Spaces

---

✨ Features

• 🖼️ Text-to-Image Generation using Stable Diffusion 2.1
• ⚡ FastAPI Backend with async support and Swagger UI
• 🎨 Beautiful Responsive Frontend with loading animations
• 🛡️ Error Handling at API and UI level
• 🐳 Docker Support for easy containerization
• ☁️ Cloud Deployment guides for AWS, GCP, and Hugging Face Spaces
• 📖 Well-Documented Code with inline comments
• 🔒 Environment Variable Management via .env
• 📊 Model Architecture Explanation (CLIP + U-Net + VAE)

---

🏗️ Architecture

User Prompt (Text)
       │
       ▼
┌─────────────────────────────────────┐
│         CLIP Text Encoder           │  ← Converts text to embeddings
│  (openai/clip-vit-large-patch14)    │
└─────────────────────────────────────┘
       │  Text Embeddings
       ▼
┌─────────────────────────────────────┐
│      U-Net Diffusion Model          │  ← Iterative denoising (50 steps)
│   (Noise → Denoised Latent Space)   │
└─────────────────────────────────────┘
       │  Denoised Latents
       ▼
┌─────────────────────────────────────┐
│         VAE Decoder                 │  ← Latents → Pixel Space (Image)
│   (Variational Autoencoder)         │
└─────────────────────────────────────┘
       │
       ▼
  Generated Image (PNG)

Components:

Component	Role
CLIP Text Encoder	Converts your text prompt into numerical embeddings
U-Net	Iteratively denoises a random noise tensor guided by the text embeddings
VAE Decoder	Decodes the denoised latent representation into a full-resolution image
Scheduler	Controls the denoising steps (PNDM, DDIM, etc.)

---

📁 Folder Structure

Image/
├── backend/                    # FastAPI backend
│   ├── main.py                 # App entry point
│   ├── config.py               # Configuration & settings
│   ├── routes/
│   │   └── generate.py         # /generate API route
│   ├── services/
│   │   └── diffusion_service.py # Stable Diffusion logic
│   └── utils/
│       └── image_utils.py      # Image processing helpers
├── frontend/                   # Web UI
│   ├── index.html              # Main HTML page
│   ├── styles.css              # Responsive CSS with animations
│   └── script.js               # API calls and UI logic
├── outputs/                    # Generated images (auto-created)
├── docs/
│   └── ARCHITECTURE.md         # Deep technical architecture
├── .env.example                # Environment variable template
├── .gitignore
├── Dockerfile
├── docker-compose.yml
├── requirements.txt            # Python dependencies
└── README.md                   # This file

---

⚙️ Installation

Prerequisites

• Python 3.10+
• CUDA-enabled GPU (recommended) OR CPU (slower)
• 8GB+ RAM / 4GB+ VRAM (GPU)
• pip or conda

Step 1: Clone the Repository

git clone https://github.com/yourusername/image-gen-ai.git
cd image-gen-ai

Step 2: Create Virtual Environment

python -m venv venv

# On Windows:
venv\Scripts\activate

# On Linux/Mac:
source venv/bin/activate

Step 3: Install Dependencies

pip install -r requirements.txt

Step 4: Configure Environment

cp .env.example .env
# Edit .env with your settings (HuggingFace token, etc.)

---

🚀 Running the Application

Start the Backend Server

uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000

Open the Frontend

Open frontend/index.html in your browser, or serve it:

python -m http.server 3000 --directory frontend

Then visit: http://localhost:3000

Access API Docs (Swagger UI)

Visit: http://localhost:8000/docs

---

📡 API Endpoints

POST /generate

Generate an image from a text prompt.

Request Body:

{
  "prompt": "a beautiful sunset over the ocean, photorealistic",
  "negative_prompt": "blurry, low quality",
  "num_inference_steps": 50,
  "guidance_scale": 7.5,
  "width": 512,
  "height": 512,
  "seed": -1
}

Response:

{
  "success": true,
  "image_base64": "data:image/png;base64,iVBORw0KGgo...",
  "image_path": "outputs/generated_1234567890.png",
  "prompt": "a beautiful sunset over the ocean, photorealistic",
  "generation_time": 12.45,
  "parameters": { ... }
}

GET /health

Check server and model status.

GET /models

List available models.

---

🌐 Deployment

🐳 Docker Deployment

docker-compose up --build

☁️ AWS EC2 Deployment

1. Launch a g4dn.xlarge instance (NVIDIA T4 GPU)
2. Install CUDA drivers and Docker
3. Clone the repo and run docker-compose up
4. Configure Security Group to allow port 8000

🌩️ Google Cloud Platform

1. Create a Compute Engine instance with NVIDIA GPU
2. Use Cloud Run for serverless deployment
3. Push Docker image to Artifact Registry

🤗 Hugging Face Spaces

1. Create a new Space with Gradio SDK
2. Upload your code
3. Set HF_TOKEN in Space secrets
4. The Space will auto-build and deploy

---

🔧 Troubleshooting

Issue	Solution
Out of memory (GPU)	Reduce width/height to 512x512, enable enable_attention_slicing
Slow generation (CPU)	Use torch_dtype=torch.float32, expect 5-10 minutes per image
Model download fails	Set HF_TOKEN in .env for gated models
Port already in use	Change port: --port 8001
CUDA not found	Install CUDA 11.8+, reinstall torch with CUDA support

---

📜 License

MIT License — free to use, modify, and distribute.

---

🙏 Acknowledgements

• Hugging Face Diffusers
• Stability AI
• FastAPI
• PyTorch