Create an AI-Generated Valentine’s Card with Python

Craft a heartfelt message and beautiful artwork for your loved ones this February 14th!

Valentine’s Day is not just about romantic love—it’s a celebration of all forms of love: the bond between family, friends, and even self-love. As the saying goes,

“Love is the bridge between you and everything.” – Rumi

In this blog post, we’ll dive into a Python project that leverages AI to generate a stunning, personalized Valentine’s card. Whether you’re a seasoned developer or a creative enthusiast, this step-by-step guide will help you understand the code and inspire you to craft your own message of love. Let’s explore how you can combine art and technology to express your heartfelt emotions!

Overview of the Project

In this project, we combine AI tools and Python libraries to create a unique Valentine’s card. The process involves:

• Image Generation: Using the Stable Diffusion model to create a vibrant, romantic background.
• Text Generation: Utilizing the Mistral model to craft a loving and heartfelt message.
• Image Processing: Applying OpenCV to overlay text with a stylish shadow effect on the generated background.

The complete code is provided below and explained in detail in this guide. With this project, you’ll not only create a visually stunning card but also experience how AI can help express emotions in creative ways.

Understanding the Code

Let’s break down the code step by step to understand how each part contributes to creating your AI-generated Valentine’s card.

Generating the Background with Stable Diffusion

The function generate_background(prompt) uses the Stable Diffusion model to create an artistic image based on a descriptive prompt.

def generate_background(prompt):
    """Generate background image using Stable Diffusion"""
    pipe = StableDiffusionPipeline.from_pretrained(
        "stabilityai/stable-diffusion-2-1",
        torch_dtype=torch.float16
    ).to("cuda" if torch.cuda.is_available() else "cpu")

    image = pipe(prompt).images[0]
    return cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)

What’s happening here?

• Model Loading: The code loads a pre-trained Stable Diffusion model optimized for generating high-quality images.
• GPU Support: It checks for GPU availability to accelerate the generation process.
• Color Conversion: The generated image is converted from RGB to BGR (OpenCV’s default format).

Tip: Experiment with different prompts to see how the background changes. Try descriptions like “vintage watercolor style with soft pastel colors and delicate heart motifs” for a different aesthetic.

Crafting a Heartfelt Message with AI

The generate_valentine_message() function leverages the Mistral model from Hugging Face’s transformers to generate a loving message.

def generate_valentine_message():
    """Generate message using Mistral model"""
    generator = pipeline('text-generation', model='mistralai/Mistral-7B-Instruct-v0.1', return_full_text=False)
    prompt = """Compose a short and loving heartfelt 50 words  Valentine's message expressing love and appreciation. """

    message = generator(prompt,
                      max_length=200,
                      temperature=0.7,
                      top_p=0.9)[0]['generated_text']
    return message

Key Points:

• Prompt Engineering: The prompt instructs the AI to generate a concise yet heartfelt message.
• Controlled Generation: Parameters like temperature and top_p are tuned for creativity while maintaining coherence.

This function is a great example of how AI can help overcome writer’s block and inspire heartfelt expressions.

Enhancing Your Card with Stylish Text

The function add_text_with_shadow() overlays text on the image with a shadow effect to make it stand out.

def add_text_with_shadow(img, text, position, font_scale=1.5):
    """Add text with shadow effect"""
    font = cv2.FONT_HERSHEY_SCRIPT_COMPLEX
    color = (50, 50, 255)  # Red color
    shadow = (20, 20, 20)   # Dark shadow

    x, y = position
    cv2.putText(img, text, (x+2, y+2), font, font_scale, shadow, 3)
    cv2.putText(img, text, (x, y), font, font_scale, color, 2)

    return img

Explanation:

• Shadow Effect: Two layers of text are drawn—one for the shadow and one for the main text—to create a 3D effect.
• Customization: You can adjust the font, color, and positioning to match your design preferences.

Bringing It All Together

The create_valentine_card() function is the heart of the project, combining background generation, message creation, and text overlay.

def create_valentine_card():
    # Generate AI background
    background = generate_background(
        "Romantic valentine background with soft lighting, heart sparkles, "
        "and rose petals, watercolor style, 4k resolution"
    )

    # Resize to 1080x1080
    card = cv2.resize(background, (1080, 1080))

    # Generate message
    message = generate_valentine_message()

    # Text positioning
    text_position = (100, 200)
    line_spacing = 60

    # Split message into lines
    words = message.split()
    lines = []
    current_line = []

    for word in words:
        current_line.append(word)
        (w, _), _ = cv2.getTextSize(' '.join(current_line), cv2.FONT_HERSHEY_SCRIPT_COMPLEX, 1.5, 2)
        if w > 900:
            current_line.pop()
            lines.append(' '.join(current_line))
            current_line = [word]
    lines.append(' '.join(current_line))

    # Add text with shadow
    for i, line in enumerate(lines):
        y = text_position[1] + i * line_spacing
        card = add_text_with_shadow(card, line, (text_position[0], y))

    # Add final decoration
    cv2.rectangle(card, (50, 50), (1030, 1030), (255, 255, 255), 5)

    return card

Process Overview:

• Background & Resizing: The AI-generated background is resized to a square format suitable for social media sharing.
• Message Layout: The generated message is split into multiple lines based on the image width, ensuring readability.
• Final Touches: A decorative rectangle borders the card, giving it a polished look.

Finally, the main block saves and displays the card:

if __name__ == "__main__":
    card = create_valentine_card()
    cv2.imwrite("AI_valentine.jpg", card)
    print("Valentine card saved as AI_valentine.jpg")

    # Display the result
    cv2_imshow(card)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

This block ensures that when you run the script, your card is saved and immediately shown. Here is the link to colab for this project

Embracing the True Meaning of Love

While this project is a fun exploration of AI and creativity, it’s also a reminder that love is universal. Beyond romantic connections, love embraces:

• Family and Friends: “Family is not an important thing, it’s everything.” – Michael J. Fox
• Self-Love: “You yourself, as much as anybody in the entire universe, deserve your love and affection.” – Buddha
• Compassion for Others: “Love and compassion are necessities, not luxuries.” – Dalai Lama

By creating a card that celebrates love in all its forms, you honor the diverse and rich connections that make life meaningful.

Get Started and Share the Love!

Now that you’ve seen how to generate a stunning AI-powered Valentine’s card, it’s your turn to spread the love! Here are some tips to personalize your creation:

• Customize the Prompt: Tweak the image generation prompt to match your personal style or the interests of your loved one.
• Modify the Message: Experiment with the text generation parameters to get a message that resonates deeply.
• Share on Social Media: Once your card is ready, share it with friends and family and let them know that love comes in many forms. Add hashtags #retured and #dramitakapoor

By merging technology with creativity, you’re not only creating a beautiful piece of art but also celebrating the idea that love is a universal language.

“Where there is love there is life.” – Mahatma Gandhi

Feel free to explore, experiment, and most importantly, have fun expressing your affection in innovative ways this Valentine’s Day!

---

Ready to dive into AI art and spread some love? Check out out work at Retured and join the conversation on how technology can bring us closer together.

Happy Coding and Happy Valentine’s Day!