Build a Story Generator with Python: A Step-by-Step Guide

Unleash your inner storyteller by building a captivating story generator using Python! This guide combines the power of Python with the user-friendly interface of Gradio and the vast resources of Hugging Face to create an interactive AI-powered storytelling experience. Whether you're a seasoned coder or just starting out, this project will walk you through every step, allowing you to craft your own unique story generator application and explore the exciting world of natural language generation.

Setting up Your Hugging Face Account and Space

To begin this exciting project, you'll need an account on Hugging Face. Hugging Face is a leading platform for AI models, datasets, and collaboration. Creating an account is free and grants you access to a wealth of resources.

1. Sign Up/Log In: Navigate to Hugging Face and create an account or log in if you already have one.
2. Create a New Space: Once logged in, look for the 'Spaces' tab on the top navigation bar. Spaces are like mini-repositories specifically designed to host and showcase ML applications. Click on 'Spaces' then 'Create new Space'.
3. Space Configuration:
   • Give your space a descriptive name like 'StoryGenerator'

     .

   • Select Gradio as the SDK. Gradio provides a simple and intuitive way to build web interfaces for your machine learning models.
   • Decide whether you want your space to be public or private. Private spaces are only accessible to you, while public spaces can be viewed by anyone.
4. Complete Creation: Click 'Create Space' to initiate the creation process. Hugging Face will set up a Git repository for your space, where you can manage your project files.

Creating the requirements.txt File

The requirements.txt file is crucial for specifying the Python libraries needed for your project. This file ensures that all dependencies are installed correctly when your application is deployed on Hugging Face. Here’s how to create it:

1. Navigate to the 'Files' Tab: Within your newly created space, find the 'Files' tab.

   

2. Add a New File: Click on 'Add file' and select 'Create new file'.

3. Name the File: Name the file requirements.txt. It’s crucial to get the name correct, as this is the standard file recognized for dependency management.

4. Specify Dependencies: In the file editor, list the necessary libraries, each on a new line. For this project, you will need the following:

   • gradio
   • transformers
   • tensorflow

5. Commit Changes: Once you've added the dependencies, scroll down to the bottom and click 'Commit new file to main'. This saves the requirements.txt file to your repository. This ensures that the Gradio, Transformers, and TensorFlow libraries will be installed in your Hugging Face Space .

Diving into the Python Code (app.py)

Now, let's get into the core of the story generator: the Python code. This code defines the logic for generating stories using a pre-trained language model. You'll be creating a file named app.py to house this code.

1. Access App Creation Link: Navigate to the 'App' section of your Hugging Face Space. Scroll down and find the link prompting you to create the app.py file directly in your browser.

   

2. Initialize the File: Click the link to open the editor for the app.py file. This is where you will write the Python code that powers your story generator.

3. Import Necessary Libraries : The first step is to import the libraries you'll be using. Here’s the code you’ll need:

   import gradio as gr
   from transformers import pipeline

   • gradio: This imports the Gradio library, which is essential for building the user interface.
   • transformers: This imports the pipeline function from the Transformers library. This pipeline simplifies using pre-trained models from Hugging Face.

4. Load the Text Generation Model:

   text_generator = pipeline('text-generation', model='gpt2')

   • This line loads the GPT-2 model for text generation. GPT-2 is a powerful pre-trained language model capable of generating coherent and creative text.

   The pipeline function simplifies model usage by handling all the complexities of loading, preprocessing, and generating text. You are specifying that the task is text-generation and the model to use is gpt2.

5. Define the Story Generation Function: Now, let’s create a function that will generate the story based on a given Prompt and WORD count:

   def generate_story(prompt, word_count):
       max_length = word_count + len(prompt.split())
       generated_text = text_generator(prompt, max_length=max_length, num_return_sequences=1)[0]['generated_text']
       return generated_text

   • generate_story(prompt, word_count): This function takes two arguments: prompt is the starting text for the story, and word_count is the desired length of the generated text.
   • max_length: This calculates the maximum length of the generated text, adding the word_count to the length of the prompt to ensure the story is roughly the desired length.
   • text_generator(prompt, max_length=max_length, num_return_sequences=1): This calls the text generation pipeline, passing the prompt and the maximum length. The num_return_sequences=1 argument specifies that only one sequence (story) should be returned.
   • return generated_text: This returns the generated story.

6. Define Example Inputs: For user convenience, you can define example prompts and word counts.

   example_inputs = [
       ["Once upon a time, in a magical forest, there was a curious rabbit named Oliver.", 100],
       ["Amidst the hustle and bustle of a busy city, there lived a lonely street musician.", 150],
       ["On a distant planet, explorers discovered an ancient alien artifact buried in the sand.", 200],
       ["Hidden in the attic of an old house, a forgotten journal revealed a family secret.", 250],
       ["In a futuristic world, a brilliant scientist invented a time-traveling device.", 300],
       ["Deep in the ocean, an underwater explorer encountered a mysterious and ancient creature.", 350]
   ]

   • This creates a list of example prompts and their corresponding word counts, which can be easily used within the Gradio interface.

7. Create the Gradio Interface: Use Gradio to define the user interface for your story generator.

   iface = gr.Interface(
       fn=generate_story,
       inputs=[
           gr.Textbox(label="Prompt"),
           gr.Slider(minimum=50, maximum=500, default=100, label="Word Count")
       ],
       outputs="text",
       title="Story Generator with Word Count",
       description="Enter a prompt and select the word count to generate a story.",
       examples=example_inputs
   )
   iface.launch()

   • gr.Interface(...): This creates a Gradio interface, linking the generate_story function to the UI elements.
   • fn=generate_story: This specifies the function that will be called when the user interacts with the interface.
   • inputs: This defines the input components: a text box for the prompt and a slider for the word count.
   • outputs: This specifies that the output will be displayed as text.
   • title and description: These add a title and description to your interface, making it more user-friendly.
   • examples: This integrates the example inputs, allowing users to quickly see how the story generator works.
   • iface.launch(): Finally, this line launches the Gradio interface, making it accessible in your Hugging Face Space.

8. Commit the Code: Save and commit the changes to the app.py file, similar to how you committed the requirements.txt file.

Customizing the Prompt for Unique Stories

The key to generating compelling stories lies in the quality of your prompts. Experiment with different prompts to explore diverse themes and narrative styles. Consider providing specific details, such as character names, locations, or plot points, to guide the AI's creative process.

For example, instead of a generic prompt like 'A knight goes on a quest,' try something more specific: 'Sir Reginald, a clumsy knight known for his terrible puns, embarks on a quest to retrieve the stolen Goblet of Giggles from the Dragon of Damp Squibs.' This will give the AI a richer foundation to build upon, resulting in a more unique and engaging story.

Here's a table of prompt examples for you to use:

Remember to be as descriptive as possible to get better results.

Exploring Different Text Generation Models

While GPT-2 is a good starting point, Hugging Face offers a wide range of text generation models, each with its own strengths and characteristics. Experimenting with different models can lead to significantly different story styles and qualities. Some models may be better at generating creative and imaginative stories, while others may excel at factual and informative content.

To switch models, modify the app.py code:

text_generator = pipeline('text-generation', model='MODEL_NAME')

Replace MODEL_NAME with the identifier of the desired model from the Hugging Face Model Hub. Ensure the new model you use is compatible with the text-generation pipeline, otherwise, it will cause errors. Hugging Face Model Hub

Adding More Features

Once you have a basic story generator working, consider adding features to make it even more compelling and user-friendly. Here are a few ideas:

• Theme Selection: Add a dropdown menu to allow users to select a story theme (e.g., fantasy, science fiction, mystery). This could be achieved by pre-defining prompts for different themes and having the dropdown selection determine which prompt is used.
• Character Customization: Implement input fields for users to specify character names, traits, and backstories. Inject these details into the prompt to create more personalized stories.
• Image Integration: Enhance the UI to display an image related to the generated story. You could use an image search API or a generative image model like DALL-E to automatically generate visuals based on the story text.
• Story Saving and Sharing: Add functionality to allow users to save their generated stories and share them on social media. You'll need to implement backend storage for this feature.
• Interactive Storytelling: For a more advanced project, explore the possibility of creating an interactive story where users can make choices that affect the plot. This would require significantly more complex logic and potentially a different model tailored for interactive text generation.

Entering a Prompt and Setting the Word Count

Once your story generator app is running on Hugging Face, using it is straightforward:

1. Accessing the App: Navigate to your Hugging Face Space. If the app is running correctly, you should see the Gradio interface you created.
2. Entering a Prompt: In the 'Prompt' textbox, enter the starting text for your story. This can be a sentence, a few words, or even a single keyword. The AI will use this prompt as a basis to generate the rest of the story.
3. Setting the Word Count: Use the 'Word Count' slider to specify the desired length of your story. The slider allows you to select a word count between 50 and 500 words. Keep in mind that this is an approximate word count, and the generated story may vary slightly in length.
4. Generating the Story: After entering your prompt and setting the word count, click the 'Submit' button. The app will then use the GPT-2 model to generate a story based on your input.
5. Viewing the Output: The generated story will be displayed in the 'Output' textbox. You can then read, copy, or share the story as you wish.

Using Example Prompts for Quick Story Generation

To quickly generate stories and explore the app's capabilities, you can use the provided example prompts:

1. Selecting an Example: Below the input fields, you’ll find a table of example prompts and their associated word counts. Click on any row in the table to automatically populate the 'Prompt' textbox and 'Word Count' slider with the example's values.
2. Generate the Story: Once the example prompt and word count are loaded, simply click the 'Submit' button to generate a story based on that example.
3. Explore the Output: The generated story will be displayed in the 'Output' textbox, allowing you to quickly see the results of different prompts and word counts. This is a great way to get a feel for how the story generator works and to discover interesting story ideas.