Code to Build a Free AI Image Generator Tool

Creating an AI image generator from scratch is an exciting project that leverages the power of deep learning and machine learning models. In this guide, we’ll walk through how to set up a simple web application using Python, Flask, and Stable Diffusion, a leading open-source image generation model.

By following these steps, you’ll learn how to build an image generation tool that can be hosted locally or on a cloud platform, with a practical and user-friendly interface.

This guide is ideal for anyone with a bit of Python programming knowledge and a passion for AI. Although running Stable Diffusion on a personal computer can be challenging without a powerful GPU, cloud-based options like Google Colab or Hugging Face Spaces can handle the workload efficiently.

Key Components and Requirements

Before diving into the setup, here are the main components needed for building this tool:

1. Python – Version 3.7 or higher is recommended.
2. Flask – This lightweight web framework will allow us to create a web interface.
3. Stable Diffusion Model – Accessed via the Hugging Face Diffusers library.
4. Torch (PyTorch) – For running the model on a GPU or CPU.

To install the necessary libraries, you can run the following command in your terminal:

pip install flask diffusers torch transformers

Let’s go through the steps in detail, from setting up the backend server to creating the HTML frontend.

Setting Up the Backend with Flask (app.py)

The backend of this application will use Flask, a Python web framework, to manage the server and route requests. The Stable Diffusion model will generate images based on user prompts submitted through the web form.

1. Initialize Flask App: Create a new Python file named app.py. This will serve as the main file for setting up and running the Flask app.
2. Load Stable Diffusion Model: Using the Hugging Face Diffusers library, we load the Stable Diffusion model and set it to run on a GPU (if available) or CPU.
3. Define Routes:
   • Homepage Route (/): Renders the HTML page where users can enter prompts.
   • Generate Image Route (/generate): Accepts a POST request with a prompt from the user and returns the generated image.

Below is the code for app.py:

Python

from flask import Flask, render_template, request, send_file
from io import BytesIO
from diffusers import StableDiffusionPipeline
import torch

app = Flask(__name__)

# Initialize Stable Diffusion model
model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
model.to("cuda" if torch.cuda.is_available() else "cpu")

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/generate', methods=['POST'])
def generate_image():
    prompt = request.form.get("prompt")
    if not prompt:
        return "Prompt is required!", 400
    
    # Generate image
    with torch.no_grad():
        image = model(prompt).images[0]

    # Convert to bytes and send as response
    img_io = BytesIO()
    image.save(img_io, 'PNG')
    img_io.seek(0)
    return send_file(img_io, mimetype='image/png')

if __name__ == '__main__':
    app.run(debug=True)

Understanding the Code

In this Flask application:

1. Model Initialization: The Stable Diffusion model is loaded using the StableDiffusionPipeline from the Hugging Face Diffusers library. The to("cuda") function is used to leverage GPU power if available.
2. Home Route (/): When accessed, this route renders an HTML template (index.html) with a prompt form for the user.
3. Generate Image Route (/generate): When the form is submitted, this route captures the prompt and uses it to generate an image. The image is then converted to bytes and returned as a downloadable PNG file.

Creating the Frontend with HTML (index.html)

The frontend is a simple HTML page where users can input prompts and view the generated images. Flask will render this HTML template, which includes a form for submitting prompts and displays the generated image upon completion.

1. Basic Structure: Create a new folder named templates in your project directory, and add a file called index.html.
2. HTML Form: The form includes a text input for the prompt and a button to submit. When submitted, it sends a POST request to the /generate route.
3. Display Image: After the image is generated, it’s displayed below the form for the user to view and download.

Here’s the code for index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AI Image Generator</title>
</head>
<body>
    <h1>AI Image Generator - Free</h1>
    <form action="/generate" method="POST">
        <label for="prompt">Enter your prompt:</label>
        <input type="text" id="prompt" name="prompt" required>
        <button type="submit">Generate Image</button>
    </form>
    {% if image_url %}
    <div>
        <h2>Generated Image:</h2>
        <img src="{{ image_url }}" alt="Generated Image">
    </div>
    {% endif %}
</body>
</html>

Running the Application Locally

After setting up app.py and index.html, you’re ready to test the application. Run the following command in your terminal:

python app.py

Once the server is running, open your web browser and go to http://127.0.0.1:5000/. You’ll see a simple interface where you can enter prompts and view the generated images.

Deploying the Application on a Cloud Platform

If you want a more scalable, production-ready setup, deploying this application on a cloud platform with GPU support is ideal. Here are a few options:

1. Google Colab: Allows you to run the application on a free GPU environment.
2. Hugging Face Spaces: Designed for hosting models and demos with minimal configuration.
3. AWS, Azure, or Google Cloud: Provides more control and resources for large-scale applications but may incur costs.

Building a free AI image generator tool with Flask and Stable Diffusion is an excellent way to dive into AI development. This guide provides a foundation for creating a simple image generation app that can be customized and expanded as you grow more familiar with image-generation models and web development.

FAQs

How do I install the required libraries?

• Run pip install flask diffusers torch transformers in your terminal.

Can I run this app without a GPU?

• Yes, but image generation may be slower on a CPU. Using a GPU is recommended for faster processing.

Is this setup suitable for production?

• For high traffic, consider deploying on a cloud service with GPU support.

What prompts work best with Stable Diffusion?

• Descriptive prompts with specific keywords help the model produce clearer images.

How can I deploy this app on Google Colab?

• Run the Flask app in a Colab notebook with the necessary libraries and forward the localhost URL using ngrok.

Is this project free to run?

• It’s free on a local machine, but cloud hosting may incur costs.

A big thank you for exploring TechsBucket! Your visit means a lot to us, and we’re grateful for your time on our platform. If you have any feedback or suggestions, we’d love to hear them.