import gradio as gr
from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
from transformers import AutoProcessor, AutoModelForVision2Seq, AutoModelForCausalLM, AutoTokenizer
import torch
from PIL import Image, ImageDraw, ImageFont
import numpy as np
import textwrap
import os
import gc
import re
import psutil
from datetime import datetime
import spaces
from kokoro import KModel, KPipeline
import soundfile as sf
import math
def clear_memory():
"""Helper function to clear both CUDA and system memory, safe for Spaces environment"""
gc.collect()
# Only perform CUDA operations if we're in a GPU task context
if hasattr(spaces, "current_task") and spaces.current_task and torch.cuda.is_available():
torch.cuda.empty_cache()
torch.cuda.synchronize()
process = psutil.Process(os.getpid())
if hasattr(process, 'memory_info'):
process.memory_info().rss
gc.collect(generation=0)
gc.collect(generation=1)
gc.collect(generation=2)
# Only log GPU stats if we're in a GPU task context
if hasattr(spaces, "current_task") and spaces.current_task and torch.cuda.is_available():
print(f"GPU Memory allocated: {torch.cuda.memory_allocated()/1024**2:.2f} MB")
print(f"GPU Memory cached: {torch.cuda.memory_reserved()/1024**2:.2f} MB")
print(f"CPU RAM used: {process.memory_info().rss/1024**2:.2f} MB")
# Initialize models at startup - only the lightweight ones
print("Loading models...")
# Load SmolVLM for image analysis
processor_vlm = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM-500M-Instruct")
model_vlm = AutoModelForVision2Seq.from_pretrained(
"HuggingFaceTB/SmolVLM-500M-Instruct",
torch_dtype=torch.bfloat16
).to("cuda")
# Load SmolLM2 for story and prompt generation
checkpoint = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
tokenizer_lm = AutoTokenizer.from_pretrained(checkpoint)
model_lm = AutoModelForCausalLM.from_pretrained(checkpoint).to("cuda")
# Initialize Kokoro TTS pipeline
pipeline = KPipeline(lang_code='a') # 'a' for American English
# Load Stable Diffusion model at startup
pipe_sd = StableDiffusionPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
torch_dtype=torch.float16,
).to("cuda")
pipe_sd.scheduler = DPMSolverMultistepScheduler.from_config(pipe_sd.scheduler.config)
pipe_sd.enable_attention_slicing()
@torch.inference_mode()
#@spaces.GPU(duration=30)
def generate_image():
"""Generate a random landscape image."""
clear_memory()
default_prompt = "a beautiful, professional landscape photograph"
default_negative_prompt = "blurry, bad quality, distorted, deformed"
default_steps = 30
default_guidance = 7.5
default_seed = torch.randint(0, 2**32 - 1, (1,)).item()
generator = torch.Generator("cuda").manual_seed(default_seed)
try:
image = pipe_sd(
prompt=default_prompt,
negative_prompt=default_negative_prompt,
num_inference_steps=default_steps,
guidance_scale=default_guidance,
generator=generator,
).images[0]
clear_memory()
return image
except Exception as e:
print(f"Error generating image: {e}")
clear_memory()
return None
@torch.inference_mode()
#@spaces.GPU(duration=30)
def analyze_image(image):
if image is None:
return "Please generate an image first."
clear_memory()
if isinstance(image, np.ndarray):
image = Image.fromarray(image)
messages = [
{
"role": "user",
"content": [
{"type": "image"},
{"type": "text", "text": "Describe this image and Be brief but descriptive."}
]
}
]
try:
prompt = processor_vlm.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor_vlm(
text=prompt,
images=[image],
return_tensors="pt"
).to('cuda')
outputs = model_vlm.generate(
input_ids=inputs.input_ids,
pixel_values=inputs.pixel_values,
attention_mask=inputs.attention_mask,
num_return_sequences=1,
no_repeat_ngram_size=2,
max_new_tokens=500,
min_new_tokens=10
)
description = processor_vlm.decode(outputs[0], skip_special_tokens=True)
description = re.sub(r".*?Assistant:\s*", "", description, flags=re.DOTALL).strip()
# Split into sentences and take only the first three
sentences = re.split(r'(?<=[.!?])\s+', description)
description = ' '.join(sentences[:9])
clear_memory()
return description
except Exception as e:
print(f"Error analyzing image: {e}")
clear_memory()
return "Error analyzing image. Please try again."
def format_story_paragraphs(story_text, max_paragraphs=9):
"""Formats the story by evenly distributing sentences over a max of 9 paragraphs."""
# Remove unwanted tokens and artifacts
story_text = story_text.replace("<|im_end|>", "").strip()
# Split into sentences
sentences = re.split(r'(?<=[.!?])\s+', story_text)
sentences = [s.strip() for s in sentences if s.strip()] # Remove empty sentences
# Determine optimal sentence distribution
total_sentences = len(sentences)
num_paragraphs = min(max_paragraphs, total_sentences) # Ensure we do not exceed max paragraphs
sentences_per_paragraph = math.ceil(total_sentences / num_paragraphs) # Distribute evenly
# Group sentences into paragraphs
paragraphs = []
current_paragraph = []
for sentence in sentences:
current_paragraph.append(sentence)
# Ensure even distribution across paragraphs
if len(current_paragraph) == sentences_per_paragraph:
paragraphs.append(" ".join(current_paragraph))
current_paragraph = []
# Stop if we reach max paragraphs
if len(paragraphs) == max_paragraphs:
break
# If there are leftover sentences, add them as a final paragraph
if current_paragraph:
paragraphs.append(" ".join(current_paragraph))
# Join paragraphs with a double newline
return "\n\n".join(paragraphs)
#@spaces.GPU(duration=60)
def generate_story(image_description):
"""Runs story generation safely on Hugging Face Spaces with Stateless GPU"""
clear_memory()
# Define story prompt
story_prompt = f"""Write a short children's story (about 200 words) based on this scene: {image_description}
Requirements:
1. Main character: An English bulldog named Champ
2. Include these values: confidence, teamwork, caring, and hope
3. Theme: "Doing the right thing is important"
4. Keep it simple and engaging for young children
5. End with a simple moral lesson"""
try:
# Move CUDA initialization inside the function
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
messages = [{"role": "user", "content": story_prompt}]
input_text = tokenizer_lm.apply_chat_template(messages, tokenize=False)
inputs = tokenizer_lm.encode(input_text, return_tensors="pt").to(device) # Move to CUDA inside function
outputs = model_lm.generate(
inputs,
max_new_tokens=750,
temperature=0.7,
top_p=0.9,
do_sample=True,
repetition_penalty=1.2
)
# Decode and format the story
story = tokenizer_lm.decode(outputs[0])
story = clean_story_output(story)
story = format_story_paragraphs(story) # Evenly distribute sentences
clear_memory()
return story
except Exception as e:
print(f"Error generating story: {e}")
clear_memory()
return "Error generating story. Please try again."
@torch.inference_mode()
#@spaces.GPU(duration=30)
def generate_image_prompts(story_text):
clear_memory()
paragraphs = split_into_paragraphs(story_text)
all_prompts = []
prompt_instruction = '''Here is a story paragraph: {paragraph}
Start your response with "Watercolor bulldog" and describe what Champ is doing in this scene. Include any friends. Add where it takes place and one mood detail. Keep it short.'''
try:
for i, paragraph in enumerate(paragraphs, 1):
messages = [{"role": "user", "content": prompt_instruction.format(paragraph=paragraph)}]
input_text = tokenizer_lm.apply_chat_template(messages, tokenize=False)
inputs = tokenizer_lm.encode(input_text, return_tensors="pt").to("cuda")
outputs = model_lm.generate(
inputs,
max_new_tokens=30,
temperature=0.5,
top_p=0.9,
do_sample=True,
repetition_penalty=1.2
)
prompt = process_generated_prompt(tokenizer_lm.decode(outputs[0]), paragraph)
section = f"Paragraph {i}:\n{paragraph}\n\nScenery Prompt {i}:\n{prompt}\n\n{'='*50}"
all_prompts.append(section)
clear_memory()
return '\n'.join(all_prompts)
except Exception as e:
print(f"Error generating prompts: {e}")
clear_memory()
return "Error generating prompts. Please try again."
@torch.inference_mode()
#@spaces.GPU(duration=60)
def generate_story_image(prompt, seed=-1):
clear_memory()
try:
pipe_sd.load_lora_weights("Prof-Hunt/lora-bulldog")
generator = torch.Generator("cuda")
if seed != -1:
generator.manual_seed(seed)
else:
generator.manual_seed(torch.randint(0, 2**32 - 1, (1,)).item())
enhanced_prompt = f"{prompt}, watercolor style, children's book illustration, soft colors"
image = pipe_sd(
prompt=enhanced_prompt,
negative_prompt="deformed, ugly, blurry, bad art, poor quality, distorted",
num_inference_steps=50,
guidance_scale=15,
generator=generator
).images[0]
pipe_sd.unload_lora_weights()
clear_memory()
return image
except Exception as e:
print(f"Error generating image: {e}")
pipe_sd.unload_lora_weights()
clear_memory()
return None
@torch.inference_mode()
#@spaces.GPU(duration=180)
def generate_all_scenes(prompts_text):
clear_memory()
generated_images = []
formatted_prompts = []
progress_messages = []
total_scenes = len([s for s in prompts_text.split('='*50) if s.strip()])
def update_progress():
"""Create a progress message showing completed/total scenes"""
completed = len(generated_images)
message = f"Generated {completed}/{total_scenes} scenes\n\n"
if progress_messages:
message += "\n".join(progress_messages[-3:]) # Show last 3 status messages
return message
sections = prompts_text.split('='*50)
for section_num, section in enumerate(sections, 1):
if not section.strip():
continue
scene_prompt = None
for line in section.split('\n'):
if 'Scenery Prompt' in line:
scene_num = line.split('Scenery Prompt')[1].split(':')[0].strip()
next_line_index = section.split('\n').index(line) + 1
if next_line_index < len(section.split('\n')):
scene_prompt = section.split('\n')[next_line_index].strip()
formatted_prompts.append(f"Scene {scene_num}: {scene_prompt}")
break
if scene_prompt:
try:
clear_memory()
status_msg = f"🎨 Creating scene {section_num}: '{scene_prompt[:50]}...'"
progress_messages.append(status_msg)
# Yield progress update
yield generated_images, "\n\n".join(formatted_prompts), update_progress()
image = generate_story_image(scene_prompt)
if image is not None:
# Convert PIL Image to numpy array with explicit mode conversion
pil_image = image if isinstance(image, Image.Image) else Image.fromarray(image)
pil_image = pil_image.convert('RGB') # Ensure RGB mode
img_array = np.array(pil_image)
# Verify array shape and type
if len(img_array.shape) == 3 and img_array.shape[2] == 3:
generated_images.append(img_array)
progress_messages.append(f"✅ Successfully completed scene {section_num}")
else:
progress_messages.append(f"❌ Error: Invalid image format for scene {section_num}")
else:
progress_messages.append(f"❌ Failed to generate scene {section_num}")
clear_memory()
except Exception as e:
error_msg = f"❌ Error generating scene {section_num}: {str(e)}"
progress_messages.append(error_msg)
clear_memory()
continue
# Yield progress update after each scene
yield generated_images, "\n\n".join(formatted_prompts), update_progress()
# Final status update
if not generated_images:
progress_messages.append("❌ No images were successfully generated")
else:
progress_messages.append(f"✅ Successfully completed all {len(generated_images)} scenes!")
# Final yield
yield generated_images, "\n\n".join(formatted_prompts), update_progress()
#@spaces.GPU(duration=60)
def add_text_to_scenes(gallery_images, prompts_text):
"""Add text overlays to all scenes"""
print(f"Received gallery_images type: {type(gallery_images)}")
print(f"Number of images in gallery: {len(gallery_images) if isinstance(gallery_images, list) else 0}")
if not isinstance(gallery_images, list):
print("Gallery images must be a list")
return [], []
clear_memory()
# Process text sections
sections = prompts_text.split('='*50)
overlaid_images = []
output_files = []
# Create temporary directory for saving files
temp_dir = "temp_book_pages"
os.makedirs(temp_dir, exist_ok=True)
for i, (img_data, section) in enumerate(zip(gallery_images, sections)):
if not section.strip():
continue
print(f"\nProcessing image {i+1}:")
print(f"Image data type: {type(img_data)}")
try:
# Handle tuple from Gradio gallery
if isinstance(img_data, tuple):
filepath = img_data[0] if isinstance(img_data[0], str) else None
print(f"Found filepath: {filepath}")
if filepath and os.path.exists(filepath):
print(f"Loading image from: {filepath}")
image = Image.open(filepath).convert('RGB')
else:
print(f"Invalid filepath: {filepath}")
continue
else:
print(f"Unexpected image data type: {type(img_data)}")
continue
# Extract paragraph text
lines = [line.strip() for line in section.split('\n') if line.strip()]
paragraph = None
for j, line in enumerate(lines):
if line.startswith('Paragraph'):
if j + 1 < len(lines):
paragraph = lines[j + 1]
print(f"Found paragraph text for image {i+1}")
break
if paragraph and image:
# Add text overlay
overlaid_img = overlay_text_on_image(image, paragraph)
if overlaid_img is not None:
# Convert to numpy array for gallery display
overlaid_array = np.array(overlaid_img)
overlaid_images.append(overlaid_array)
# Save file for download
output_path = os.path.join(temp_dir, f"panel_{i+1}.png")
overlaid_img.save(output_path)
output_files.append(output_path)
print(f"Successfully processed image {i+1}")
else:
print(f"Failed to overlay text on image {i+1}")
except Exception as e:
print(f"Error processing image {i+1}: {str(e)}")
import traceback
print(traceback.format_exc())
continue
if not overlaid_images:
print("No images were successfully processed")
else:
print(f"Successfully processed {len(overlaid_images)} images")
clear_memory()
return overlaid_images, output_files
def overlay_text_on_image(image, text):
"""Add black text with white outline for better visibility."""
if image is None:
return None
try:
# Ensure we're working with RGB mode
img = image.convert('RGB')
draw = ImageDraw.Draw(img)
# Calculate font size based on image dimensions
font_size = int(img.width * 0.025)
try:
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", font_size)
except:
print("Using default font as DejaVuSans-Bold.ttf not found")
font = ImageFont.load_default()
# Calculate text positioning
y_position = int(img.height * 0.005)
x_margin = int(img.width * 0.005)
available_width = img.width - (2 * x_margin)
# Wrap text to fit image width
wrapped_text = textwrap.fill(text, width=int(available_width / (font_size * 0.6)))
# Add white outline to text for better readability
outline_color = (255, 255, 255)
text_color = (0, 0, 0)
offsets = [-2, -1, 1, 2]
# Draw text outline
for dx in offsets:
for dy in offsets:
draw.multiline_text(
(x_margin + dx, y_position + dy),
wrapped_text,
font=font,
fill=outline_color
)
# Draw main text
draw.multiline_text(
(x_margin, y_position),
wrapped_text,
font=font,
fill=text_color
)
return img
except Exception as e:
print(f"Error in overlay_text_on_image: {e}")
return None
#@spaces.GPU(duration=60)
def generate_combined_audio_from_story(story_text, voice='af_heart', speed=1):
"""Generate a single audio file for all paragraphs in the story."""
# Use existing paragraph logic (from your original function)
paragraphs = []
current_paragraph = []
for line in story_text.split('\n'):
line = line.strip()
if not line: # Empty line indicates paragraph break
if current_paragraph:
paragraphs.append(' '.join(current_paragraph))
current_paragraph = []
else:
current_paragraph.append(line)
if current_paragraph:
paragraphs.append(' '.join(current_paragraph))
# Combine audio for all paragraphs
combined_audio = []
for paragraph in paragraphs:
if not paragraph.strip():
continue # Skip empty paragraphs
generator = pipeline(
paragraph,
voice=voice,
speed=speed,
split_pattern=r'\n+' # Split on newlines
)
for _, _, audio in generator:
combined_audio.extend(audio) # Append audio data
# Convert combined audio to NumPy array
combined_audio = np.array(combined_audio)
# Save audio as a WAV file in Hugging Face's temporary directory
filename = "/tmp/combined_story.wav"
sf.write(filename, combined_audio, 24000)
clear_memory()
return filename # Returning filename for Gradio File component
# Helper functions
def clean_story_output(story):
"""Clean up the generated story text."""
story = story.replace("<|im_end|>", "")
story_start = story.find("Once upon")
if story_start == -1:
possible_starts = ["One day", "In a", "There was", "Champ"]
for marker in possible_starts:
story_start = story.find(marker)
if story_start != -1:
break
if story_start != -1:
story = story[story_start:]
lines = story.split('\n')
cleaned_lines = []
for line in lines:
line = line.strip()
if line and not any(skip in line.lower() for skip in ['requirement', 'include these values', 'theme:', 'keep it simple', 'end with', 'write a']):
if not line.startswith(('1.', '2.', '3.', '4.', '5.')):
cleaned_lines.append(line)
return '\n\n'.join(cleaned_lines).strip()
def split_into_paragraphs(text):
"""Split text into paragraphs."""
paragraphs = []
current_paragraph = []
for line in text.split('\n'):
line = line.strip()
if not line:
if current_paragraph:
paragraphs.append(' '.join(current_paragraph))
current_paragraph = []
else:
current_paragraph.append(line)
if current_paragraph:
paragraphs.append(' '.join(current_paragraph))
return [p for p in paragraphs if not any(skip in p.lower()
for skip in ['requirement', 'include these values', 'theme:',
'keep it simple', 'end with', 'write a'])]
def process_generated_prompt(prompt, paragraph):
"""Process and clean up generated image prompts."""
prompt = prompt.replace("<|im_start|>", "").replace("<|im_end|>", "")
prompt = prompt.replace("assistant", "").replace("system", "").replace("user", "")
cleaned_lines = [line.strip() for line in prompt.split('\n')
if line.strip().lower().startswith("watercolor bulldog")]
if cleaned_lines:
prompt = cleaned_lines[0]
else:
setting = "quiet town" if "quiet town" in paragraph.lower() else "park"
mood = "hopeful" if "wished" in paragraph.lower() else "peaceful"
prompt = f"Watercolor bulldog watching friends play in {setting}, {mood} atmosphere."
if not prompt.endswith('.'):
prompt = prompt + '.'
return prompt
def create_interface():
# Define CSS for custom styling
css = """
/* Global styles */
.gradio-container {
background-color: #EBF8FF !important;
}
/* Custom button styling */
.custom-button {
background-color: #3B82F6 !important;
color: white !important;
border: none !important;
border-radius: 8px !important;
padding: 10px 20px !important;
margin: 10px 0 !important;
min-width: 200px !important;
}
.custom-button:hover {
background-color: #2563EB !important;
}
/* Section styling */
.section-content {
background-color: white !important;
border-radius: 12px !important;
padding: 20px !important;
margin: 10px 0 !important;
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05) !important;
}
/* AI Lesson box styling */
.ai-lesson {
background-color: #FEE2E2 !important;
border-radius: 8px !important;
padding: 15px !important;
margin: 10px 0 !important;
border: 1px solid #FCA5A5 !important;
}
"""
with gr.Blocks(css=css) as demo:
gr.Markdown("""
# 🎨 Tech Tales: AI Children's Story Creator
Welcome to this educational AI story creation tool! This app demonstrates how multiple AI models
work together to create an illustrated children's story. Each step includes a brief AI lesson
to help you understand the technology being used.
Let's create something magical! ✨
## 📌 [Open in Google Colab](https://colab.research.google.com/drive/18-4frRwaMxxqJrRjiXh1Q069R77INMeA?usp=sharing) 🚀
""")
# Step 1: Generate Landscape
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 1: Setting the Scene with AI 🖼️
🤖 **AI Lesson: Text-to-Image Generation**
We're using Stable Diffusion, a powerful AI model that turns text into images.
How it works:
- Starts with random noise and gradually refines it into an image
- Uses millions of image-text pairs from its training
- Combines understanding of both language and visual elements
- Takes about 50 steps to create each image
Real-world applications: Book illustrations, concept art, product visualization
""")
with gr.Column():
generate_btn = gr.Button("1. Generate Random Landscape", elem_classes="custom-button")
image_output = gr.Image(label="Your AI-Generated Landscape", type="pil", interactive=False)
# Step 2: Analyze Scene
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 2: Teaching AI to See 👁️
🤖 **AI Lesson: Vision-Language Models (VLM)**
Our VLM acts like an AI art critic, understanding and describing images.
How it works:
- Processes images through neural networks
- Identifies objects, scenes, colors, and relationships
- Translates visual features into natural language
- Uses attention mechanisms to focus on important details
Real-world applications: Image search, accessibility tools, medical imaging
""")
with gr.Column():
analyze_btn = gr.Button("2. Get Brief Description", elem_classes="custom-button")
analysis_output = gr.Textbox(label="What the AI Sees", lines=3)
# Step 3: Create Story
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 3: Crafting the Narrative 📖
🤖 **AI Lesson: Large Language Models**
Meet our AI storyteller! It uses a Large Language Model (LLM) to write creative stories.
How it works:
- Processes the scene description as context
- Uses pattern recognition from millions of stories
- Maintains narrative consistency and character development
- Adapts its writing style for children
Real-world applications: Content creation, creative writing, education
""")
with gr.Column():
story_btn = gr.Button("3. Create Children's Story", elem_classes="custom-button")
story_output = gr.Textbox(label="Your AI-Generated Story", lines=10)
# Step 4: Generate Prompts
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 4: Planning the Illustrations 🎯
🤖 **AI Lesson: Natural Language Processing**
The AI breaks down the story into key scenes and creates optimal image prompts.
How it works:
- Analyzes story structure and pacing
- Identifies key narrative moments
- Generates specialized prompts for each scene
- Ensures visual consistency across illustrations
Real-world applications: Content planning, storyboarding, scene composition
""")
with gr.Column():
prompts_btn = gr.Button("4. Generate Scene Prompts", elem_classes="custom-button")
prompts_output = gr.Textbox(label="Scene Descriptions", lines=20)
# Step 5: Generate Scenes
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 5: Bringing Scenes to Life 🎨
🤖 **AI Lesson: Specialized Image Generation**
Using a fine-tuned model to create consistent character illustrations.
How it works:
- Uses LoRA (Low-Rank Adaptation) for specialized training
- Maintains consistent character appearance
- Processes multiple scenes in parallel
- Balances creativity with prompt adherence
Real-world applications: Character design, animation, book illustration
""")
with gr.Column():
generate_scenes_btn = gr.Button("5. Generate Story Scenes", elem_classes="custom-button")
scene_progress = gr.Textbox(label="Generation Progress", lines=6, interactive=False)
gallery = gr.Gallery(label="Story Scenes", columns=2, height="auto", interactive=False)
scene_prompts_display = gr.Textbox(label="Scene Details", lines=8, interactive=False)
# Step 6: Add Text
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 6: Creating Book Pages 📚
🤖 **AI Lesson: Computer Vision & Layout**
Combining images and text requires sophisticated layout algorithms.
How it works:
- Analyzes image composition for text placement
- Adjusts font size and style for readability
- Creates visual hierarchy between elements
- Ensures consistent formatting across pages
Real-world applications: Desktop publishing, web design, digital books
""")
with gr.Column():
add_text_btn = gr.Button("6. Add Text to Scenes", elem_classes="custom-button")
final_gallery = gr.Gallery(label="Final Book Pages", columns=2, height="auto", interactive=False)
download_btn = gr.File(label="Download Your Story Book", file_count="multiple", interactive=False)
# Step 7: Audio Generation
with gr.Row(elem_classes="section-content"):
with gr.Column(elem_classes="ai-lesson"):
gr.Markdown("""
### Step 7: Adding Narration 🎧
🤖 **AI Lesson: Text-to-Speech Synthesis**
Converting our story into natural-sounding speech.
How it works:
- Uses neural networks for voice synthesis
- Adds appropriate emotion and emphasis
- Controls pacing and pronunciation
- Maintains consistent voice throughout
Real-world applications: Audiobooks, accessibility tools, virtual assistants
""")
with gr.Column():
tts_btn = gr.Button("7. Read Story Aloud", elem_classes="custom-button")
audio_output = gr.Audio(label="Story Narration")
# Event handlers
generate_btn.click(fn=generate_image, outputs=image_output)
analyze_btn.click(fn=analyze_image, inputs=[image_output], outputs=analysis_output)
story_btn.click(fn=generate_story, inputs=[analysis_output], outputs=story_output)
prompts_btn.click(fn=generate_image_prompts, inputs=[story_output], outputs=prompts_output)
generate_scenes_btn.click(
fn=generate_all_scenes,
inputs=[prompts_output],
outputs=[gallery, scene_prompts_display, scene_progress]
)
add_text_btn.click(
fn=add_text_to_scenes,
inputs=[gallery, prompts_output],
outputs=[final_gallery, download_btn]
)
tts_btn.click(fn=generate_combined_audio_from_story, inputs=[story_output], outputs=audio_output)
return demo
if __name__ == "__main__":
demo = create_interface()
demo.launch()